Embedding and packages

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "41"
      }
    }
  ],
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "host-callback",
        "behavior": "returns the exact integer 42"
      }
    }
  ],
  "admission": "Attempt to supply a host function as the input datum.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "41"
      }
    },
    {
      "input": {
        "kind": "integer",
        "value": "7"
      }
    }
  ],
  "preparation": "Prepare this closed bundle once and keep its verified immutable handle.",
  "execution": "Evaluate the two inputs as separate requests with independent copies of the same finite evaluation limits.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "0"
      }
    }
  ],
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "rootModule": "규칙",
  "moduleSources": [
    {
      "name": "규칙",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "bundleRoot": "규칙",
    "moduleName": "규칙",
    "inputInteger": "41"
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "mutation": "Remove only the required root field from a one-module bundle."
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "cases": [
      "Remove work from otherwise complete finite limits.",
      "Set work to exact integer -1.",
      "Add timeout to otherwise complete finite limits."
    ]
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "sequence": [
      "prepare",
      "evaluate 41",
      "release",
      "evaluate 7",
      "release",
      "export resolved/1",
      "load into a new instance",
      "evaluate 41"
    ]
  }
}

pub struct Product { private: private::ProductState }
pub struct PreparedRule { private: private::SealedProgram }
pub struct Nat { private: private::ExactNatural }
pub type Bytes = Box<[u8]>;
pub type IdentityBytes = Bytes;
pub type CanonicalInputBytes = Bytes;
pub type RecordInputBytes = Bytes;
pub type ProfileRequestBytes = Bytes;
pub type PreparedArtifactBytes = Bytes;
pub type CommandResultBytes = Bytes;
pub type PackageBytes = Bytes;
pub type PackageMetadataBytes = Bytes;
pub struct ModuleSource { pub name: String, pub source: Bytes }
pub struct SourceBundle { pub modules: Vec<ModuleSource>, pub root: String }
pub struct FixedSelection {
    pub language: String, pub library: IdentityBytes,
    pub resource_model: IdentityBytes, pub unicode: IdentityBytes,
}
pub struct PrepareLimits {
    pub allocation: Nat, pub diagnostic: Nat, pub frames: Nat,
    pub input: Nat, pub result: Nat, pub work: Nat,
}
pub struct EvaluationLimits {
    pub allocation: Nat, pub diagnostic: Nat, pub frames: Nat,
    pub input: Nat, pub result: Nat, pub work: Nat,
}
pub struct ProfileHostBudget {
    pub resource_model: IdentityBytes,
    pub work: Nat, pub allocation: Nat, pub frames: Nat,
    pub input: Nat, pub report: Nat, pub evidence: Nat,
}
pub enum ProfileSelection { Base, Vouch2 }
pub struct TraceOptions { pub allocation: Nat, pub capacity: Nat, pub work: Nat }
pub enum PreparedFormat { Resolved1, Bytecode1 }
pub enum PrepareReply {
    Prepared { rule: PreparedRule, report: CommandResultBytes },
    Refused { report: CommandResultBytes },
}
pub enum BuildResult<T> { Value(T), Refused { report: CommandResultBytes } }
pub fn nat(product: &Product, text: &str) -> BuildResult<Nat>;
pub enum TransportFailure { InvalidCall, HostFailure }
pub trait Host {
    fn prepare(&self, bundle: SourceBundle, selection: FixedSelection,
        limits: PrepareLimits) -> Result<PrepareReply, TransportFailure>;
    fn load(&self, artifact: PreparedArtifactBytes, selection: FixedSelection,
        limits: PrepareLimits) -> Result<PrepareReply, TransportFailure>;
    fn evaluate(&self, rule: &PreparedRule, input: CanonicalInputBytes,
        limits: EvaluationLimits, trace: Option<TraceOptions>)
        -> Result<CommandResultBytes, TransportFailure>;
    fn admit_record(&self, record: RecordInputBytes, profile: ProfileSelection,
        budget: ProfileHostBudget) -> Result<CommandResultBytes, TransportFailure>;
    fn evaluate_profile(&self, rule: &PreparedRule, input: CanonicalInputBytes,
        limits: EvaluationLimits, profile_request: ProfileRequestBytes,
        budget: ProfileHostBudget, trace: Option<TraceOptions>)
        -> Result<CommandResultBytes, TransportFailure>;
    fn export(&self, rule: &PreparedRule, format: PreparedFormat,
        limits: PrepareLimits) -> Result<CommandResultBytes, TransportFailure>;
    fn graph(&self, rule: &PreparedRule, limits: PrepareLimits)
        -> Result<CommandResultBytes, TransportFailure>;
}
// Product implements Host. nat uses canonical unsigned decimal text.
// Byte aliases denote complete packets from their owning contracts.
// ProfileHostBudget encoding writes its fixed format and explicit host model.
// Base evaluate writes profile false. evaluate_profile writes ProfileEvaluation.
// admit_record runs only the separate host record operation.
// Private fields and the private module are inaccessible to callers.

export type Bytes = Uint8Array;
export type IdentityBytes = Bytes;
export type CanonicalInputBytes = Bytes;
export type RecordInputBytes = Bytes;
export type ProfileRequestBytes = Bytes;
export type PreparedArtifactBytes = Bytes;
export type CommandResultBytes = Bytes;
export type PackageBytes = Bytes;
export type PackageMetadataBytes = Bytes;
export type Nat = bigint;
export type PreparedFormat = 'resolved/1' | 'bytecode/1';
export type ProfileSelection = 'base' | 'vouch/2';
export declare class Product { private constructor(); private readonly brand; }
export declare class PreparedRule { private constructor(); private readonly brand; }
export declare class ModuleSource { private constructor(); private readonly brand; }
export declare class SourceBundle { private constructor(); private readonly brand; }
export declare class FixedSelection { private constructor(); private readonly brand; }
export declare class PrepareLimits { private constructor(); private readonly brand; }
export declare class EvaluationLimits { private constructor(); private readonly brand; }
export declare class ProfileHostBudget { private constructor(); private readonly brand; }
export declare class TraceOptions { private constructor(); private readonly brand; }
export declare class TransportFailure extends Error {
  readonly kind: 'invalid-call' | 'host-failure';
}
export type BuildResult<T> =
  | Readonly<{ kind: 'value'; value: T }>
  | Readonly<{ kind: 'refused'; report: CommandResultBytes }>;
export type PrepareReply =
  | Readonly<{ kind: 'prepared'; rule: PreparedRule; report: CommandResultBytes }>
  | Readonly<{ kind: 'refused'; report: CommandResultBytes }>;
export declare function moduleSource(p: Product, name: string, source: Bytes): BuildResult<ModuleSource>;
export declare function sourceBundle(p: Product, root: string, ...modules: ModuleSource[]): BuildResult<SourceBundle>;
export declare function fixedSelection(p: Product, language: '2.0', library: IdentityBytes,
  resourceModel: IdentityBytes, unicode: IdentityBytes): BuildResult<FixedSelection>;
export declare function prepareLimits(p: Product, allocation: Nat, diagnostic: Nat, frames: Nat,
  input: Nat, result: Nat, work: Nat): BuildResult<PrepareLimits>;
export declare function evaluationLimits(p: Product, allocation: Nat, diagnostic: Nat, frames: Nat,
  input: Nat, result: Nat, work: Nat): BuildResult<EvaluationLimits>;
export declare function profileHostBudget(p: Product, resourceModel: IdentityBytes,
  work: Nat, allocation: Nat, frames: Nat, input: Nat, report: Nat,
  evidence: Nat): BuildResult<ProfileHostBudget>;
export declare function traceOptions(p: Product, allocation: Nat, capacity: Nat, work: Nat): BuildResult<TraceOptions>;
export declare function prepare(p: Product, bundle: SourceBundle, selection: FixedSelection,
  limits: PrepareLimits): PrepareReply;
export declare function load(p: Product, artifact: PreparedArtifactBytes, selection: FixedSelection,
  limits: PrepareLimits): PrepareReply;
export declare function evaluate(rule: PreparedRule, input: CanonicalInputBytes,
  limits: EvaluationLimits, trace: TraceOptions | null): CommandResultBytes;
export declare function admitRecord(p: Product, record: RecordInputBytes,
  profile: ProfileSelection, budget: ProfileHostBudget): CommandResultBytes;
export declare function evaluateProfile(rule: PreparedRule, input: CanonicalInputBytes,
  limits: EvaluationLimits, profileRequest: ProfileRequestBytes,
  budget: ProfileHostBudget, trace: TraceOptions | null): CommandResultBytes;
export declare function exportPrepared(rule: PreparedRule, format: PreparedFormat,
  limits: PrepareLimits): CommandResultBytes;
export declare function graph(rule: PreparedRule, limits: PrepareLimits): CommandResultBytes;
export declare function dispose(rule: PreparedRule): void;

#include <stddef.h>
#include <stdint.h>
typedef struct lispex_v2_product lispex_v2_product;
typedef struct lispex_v2_prepared lispex_v2_prepared;
typedef struct { const uint8_t *data; size_t len; } lispex_v2_view;
typedef struct { uint8_t *data; size_t len; } lispex_v2_bytes;
enum lispex_v2_transport { LISPEX_V2_REPLY = 0, LISPEX_V2_INVALID_CALL = 1, LISPEX_V2_HOST_FAILURE = 2 };
uint32_t lispex_v2_prepare(const lispex_v2_product *product,
    lispex_v2_view bundle, lispex_v2_view selection, lispex_v2_view limits,
    lispex_v2_prepared **out_rule, lispex_v2_bytes *out_reply);
uint32_t lispex_v2_load(const lispex_v2_product *product,
    lispex_v2_view artifact, lispex_v2_view selection, lispex_v2_view limits,
    lispex_v2_prepared **out_rule, lispex_v2_bytes *out_reply);
uint32_t lispex_v2_evaluate(const lispex_v2_prepared *rule,
    lispex_v2_view input, lispex_v2_view limits, lispex_v2_view trace,
    lispex_v2_bytes *out_reply);
uint32_t lispex_v2_admit_record(const lispex_v2_product *product,
    lispex_v2_view record, lispex_v2_view profile, lispex_v2_view budget,
    lispex_v2_bytes *out_reply);
uint32_t lispex_v2_evaluate_profile(const lispex_v2_prepared *rule,
    lispex_v2_view input, lispex_v2_view limits, lispex_v2_view profile_request,
    lispex_v2_view budget, lispex_v2_view trace, lispex_v2_bytes *out_reply);
uint32_t lispex_v2_export(const lispex_v2_prepared *rule,
    lispex_v2_view format, lispex_v2_view limits, lispex_v2_bytes *out_reply);
uint32_t lispex_v2_graph(const lispex_v2_prepared *rule,
    lispex_v2_view limits, lispex_v2_bytes *out_reply);
void lispex_v2_prepared_destroy(lispex_v2_prepared **rule);
void lispex_v2_bytes_destroy(lispex_v2_bytes *bytes);
/* bundle contains SourceBundleBytes. artifact contains PreparedArtifactBytes.
 * selection contains FixedSelectionBytes.
 * prepare, load, export, and graph limits contain PrepareLimitsBytes.
 * evaluate and evaluate_profile limits contain EvaluationLimitsBytes.
 * input contains CanonicalInputBytes. record contains RecordInputBytes.
 * profile contains ProfileSelectionBytes.
 * profile_request contains ProfileRequestBytes.
 * budget contains ProfileHostBudgetBytes with explicit resource_model.
 * trace contains TraceOptionsBytes. format contains PreparedFormatBytes.
 * out_reply contains complete CommandResultBytes.
 * Base evaluate writes profile false. evaluate_profile writes ProfileEvaluation.
 * admit_record never enters the raw evaluator ABI.
 * Destroy sets the caller's pointer and length to zero.
 * Nonzero transport status leaves outputs zero and exposes no receipt.
 * A completed refusal has status zero, a report, and no prepared handle.
 */

{
  "notation": "documentation-request",
  "source": "source.scm",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one verified fixed library identity",
    "unicode": "one verified fixed Unicode contract identity",
    "resourceModel": "one verified fixed evaluation resource model"
  },
  "limits": {
    "prepare": "finite values sufficient for preparation",
    "evaluate": "one complete finite EvaluationLimits record sufficient for the case"
  },
  "fixtureParameterTypes": {
    "W": "exact nonnegative integer",
    "A": "exact nonnegative integer",
    "F": "exact nonnegative integer",
    "I": "exact nonnegative integer",
    "R": "exact nonnegative integer",
    "E": "exact nonnegative integer"
  },
  "budgetNotation": "Symbolic fields name finite fixture parameters. They are not public serialized strings.",
  "operation": "typed record admission followed by typed profile evaluation",
  "selectedProfile": "base",
  "recordInput": {
    "format": "lispex.record/2",
    "value": [
      "record",
      [
        [
          "x",
          [
            "datum",
            {
              "kind": "integer",
              "value": "7"
            }
          ]
        ]
      ]
    ]
  },
  "recordBudget": {
    "format": "lispex.profile-host-budget/2",
    "resource_model": "verified explicitly selected host model",
    "work": "W",
    "allocation": "A",
    "frames": "F",
    "input": "I",
    "report": "R",
    "evidence": "E"
  },
  "evaluationProfileBudget": {
    "format": "lispex.profile-host-budget/2",
    "resource_model": "verified explicitly selected host model",
    "work": "W",
    "allocation": "A",
    "frames": "F",
    "input": "I",
    "report": "R",
    "evidence": "E"
  },
  "budgetConstraints": "Both complete budgets are finite and sufficient. Each call opens its own account.",
  "profileRequest": "Complete ProfileRequestBytes for the canonical base declaration of the verified program",
  "calls": [
    "admit_record with the record packet, base selection, and recordBudget",
    "evaluate_profile with the returned input payload bytes, verified rule, fixed evaluation limits, explicit profile request, evaluationProfileBudget, and trace false"
  ],
  "apiBindings": {
    "rust": [
      "admit_record",
      "evaluate_profile"
    ],
    "typescript": [
      "admitRecord",
      "evaluateProfile"
    ],
    "c": [
      "lispex_v2_admit_record",
      "lispex_v2_evaluate_profile"
    ]
  }
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one verified fixed library identity",
    "unicode": "one verified fixed Unicode contract identity",
    "resourceModel": "one verified fixed evaluation resource model"
  },
  "limits": {
    "prepare": "finite values sufficient for preparation",
    "evaluate": "one complete finite EvaluationLimits record sufficient for the case"
  },
  "fixtureParameterTypes": {
    "W": "exact nonnegative integer",
    "A": "exact nonnegative integer",
    "F": "exact nonnegative integer",
    "I": "exact nonnegative integer",
    "R": "exact nonnegative integer",
    "E": "exact nonnegative integer"
  },
  "budgetNotation": "Symbolic fields name finite fixture parameters. They are not public serialized strings.",
  "operation": "compare two evaluate_profile calls",
  "canonicalInput": {
    "kind": "integer",
    "value": "7"
  },
  "profileRequest": "The same complete ProfileRequestBytes for the canonical base declaration",
  "profileHostBudgets": [
    {
      "format": "lispex.profile-host-budget/2",
      "resource_model": "verified supported host model A",
      "work": "W",
      "allocation": "A",
      "frames": "F",
      "input": "I",
      "report": "R",
      "evidence": "E"
    },
    {
      "format": "lispex.profile-host-budget/2",
      "resource_model": "verified supported host model B",
      "work": "W",
      "allocation": "A",
      "frames": "F",
      "input": "I",
      "report": "R",
      "evidence": "E"
    }
  ],
  "constraints": "A and B are distinct supported host model identities. All six numeric host limits are equal and sufficient in both calls. The program, input, evaluation model, evaluation limits, and profile declaration are identical.",
  "trace": false
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "record": {
      "body": {
        "format": "resolved/1",
        "limits": {
          "allocation": 0,
          "diagnostic": 0,
          "frames": 0,
          "input": 0,
          "result": 0,
          "work": 0
        }
      },
      "format": "lispex.host/2",
      "operation": "export"
    },
    "purpose": "Encoding only. Zero finite limits do not assert successful export execution."
  }
}

6c69737065782e646174756d2f3200a60108080604626f647908080606666f726d6174060a7265736f6c7665642f31080806066c696d6974730808060a616c6c6f636174696f6e03000808060a646961676e6f737469630300080806066672616d6573030008080605696e707574030008080606726573756c74030008080604776f726b0300000008080606666f726d6174060d6c69737065782e686f73742f32080806096f7065726174696f6e06066578706f727400

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "instance": "new empty admitted instance",
    "operation": "evaluate",
    "input": "canonical integer 41",
    "limits": "complete sufficient finite evaluation limits"
  }
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "42"
      }
    }
  ],
  "artifactCandidate": {
    "kind": "evaluator-artifact-description",
    "hostImports": [
      "file-read"
    ],
    "otherAdmissionChecks": "satisfied"
  },
  "execution": "Attempt to admit an evaluator whose host import grants guest file access.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "42"
      }
    }
  ],
  "preparedCandidate": {
    "kind": "transported-prepared-bytes-description",
    "version": "one supported prepared artifact version",
    "structure": "malformed",
    "otherAdmissionChecks": "satisfied"
  },
  "execution": "Attempt evaluation after receiving malformed prepared bytes from a caller.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "operations": [
      "CLI prepare",
      "typed prepare",
      "export resolved/1",
      "export bytecode/1"
    ],
    "compare": "Same complete bundle and fixed dependencies."
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "containerMutation": {
      "payload-format": "resolved/1",
      "payload": "otherwise valid bytecode/1 bytes"
    }
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "mutation": "Change only the outer program identity to a different valid identity."
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "mutations": [
      "Add one host import.",
      "Add a start section.",
      "Add one extra export."
    ],
    "artifact": "otherwise matching candidate evaluator"
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "sequence": [
      "prepare and release",
      "allocate one evaluation request",
      "call once for input 41",
      "read response pointer and length twice",
      "release twice"
    ]
  }
}

{
  "notation": "documentation-request",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ],
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "Unicode 17.0.0",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite limits sufficient for these operations",
    "evaluate": "finite limits sufficient for the stated evaluation"
  },
  "cases": {
    "artifact": "A module has exactly the declared exports, zero imports, and no start section. Its identity has no installed support evidence."
  }
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "list",
        "items": [
          {
            "kind": "integer",
            "value": "9"
          },
          {
            "kind": "integer",
            "value": "10"
          }
        ]
      }
    },
    {
      "input": {
        "kind": "list",
        "items": [
          {
            "kind": "integer",
            "value": "9"
          },
          {
            "kind": "integer",
            "value": "10"
          }
        ]
      }
    },
    {
      "input": {
        "kind": "list",
        "items": [
          {
            "kind": "integer",
            "value": "11"
          },
          {
            "kind": "integer",
            "value": "10"
          }
        ]
      }
    }
  ],
  "hostContext": {
    "adapter": "Topaz std.lispex",
    "inputMeaning": "The list holds a captured time value followed by a cutoff value.",
    "liveClockAcrossRequests": [
      9,
      11,
      11
    ],
    "actionPolicy": "Observe the returned values without performing an external action."
  },
  "execution": "Replay the first captured input after the host clock changes. Then submit a newly captured input as a different request.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}

{
  "notation": "documentation-request",
  "source": "source.scm",
  "semantics": {
    "language": "Lispex 2.0",
    "standardLibrary": "one fixed library identity",
    "unicode": "one fixed Unicode semantics version",
    "resourceModel": "one fixed finite resource model"
  },
  "limits": {
    "prepare": "finite values sufficient to prepare this source",
    "evaluate": "finite values sufficient for the stated finite calculation"
  },
  "requests": [
    {
      "input": {
        "kind": "integer",
        "value": "42"
      }
    },
    {
      "input": {
        "kind": "integer",
        "value": "42"
      }
    }
  ],
  "packageCandidates": [
    {
      "defect": "the installed standard library identity differs from the requested fixed library",
      "otherAdmissionChecks": "satisfied"
    },
    {
      "defect": "the installed value codec identity differs from the requested codec",
      "otherAdmissionChecks": "satisfied"
    }
  ],
  "execution": "Submit each request to the described installed package without loading replacement components.",
  "rootModule": "main",
  "moduleSources": [
    {
      "name": "main",
      "source": "source.scm"
    }
  ]
}