@kortexya/reasoninglayer 1.13.0 → 1.15.0

package/dist/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var SDK_VERSION = "1.13.0";
+var SDK_VERSION = "1.15.0";
 function resolveConfig(config) {
   if (!config.baseUrl) {
     throw new Error("ClientConfig.baseUrl is required");
@@ -541,29 +541,61 @@ var HttpClient = class {
   };
 };
 
-// src/serialization.ts
+// src/user-data-fields.ts
 var USER_DATA_FIELDS = /* @__PURE__ */ new Set([
-  // features — term/query feature maps (Record<string, ValueDto>)
-  "features",
-  // bindings — variable binding maps
+  "annotations",
+  "answers",
+  "antecedentFeatures",
+  "antecedent_features",
   "bindings",
-  // evidence — causal evidence maps
+  "coefficients",
+  "conceptValues",
+  "concept_values",
+  "contextDependentRelations",
+  "context_dependent_relations",
+  "correctPattern",
+  "correct_pattern",
+  "currentValues",
+  "current_values",
+  "dataVersions",
+  "data_versions",
   "evidence",
-  // exogenous values — causal intervention values
-  "exogenous_values",
-  "exogenousValues",
-  // modified/suggested params — action review params
-  "modified_params",
+  "extra",
+  "extracted",
+  "features",
+  "fieldTypes",
+  "field_types",
+  "filter",
+  "initialBindings",
+  "initial_bindings",
+  "inputs",
+  "interventions",
   "modifiedParams",
-  "suggested_params",
-  "suggestedParams",
-  // match key — row matching keys
-  "match_key",
-  "matchKey",
-  // concept values — RAG concept values
-  "concept_values",
-  "conceptValues"
+  "modified_params",
+  "observations",
+  "optionalInputs",
+  "optional_inputs",
+  "original",
+  "originalValues",
+  "original_values",
+  "outputs",
+  "perStrategyTaxonomies",
+  "per_strategy_taxonomies",
+  "propsOverride",
+  "props_override",
+  "roleMinimums",
+  "role_minimums",
+  "scope",
+  "scoresByName",
+  "scores_by_name",
+  "sortNames",
+  "sort_names",
+  "topK",
+  "top_k",
+  "values"
 ]);
+
+// src/serialization.ts
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -630,11 +662,11 @@ function buildAuthHeaders(config) {
   return headers;
 }
 function transformRequestInit(init) {
-  if (!init?.body || typeof init.body !== "string") return init;
-  const headers = init.headers;
-  if (hasRawBodyHeader(headers)) {
-    return { ...init, headers: withoutRawBodyHeader(headers) };
+  if (!init) return init;
+  if (hasRawBodyHeader(init.headers)) {
+    return { ...init, headers: withoutRawBodyHeader(init.headers) };
   }
+  if (!init.body || typeof init.body !== "string") return init;
   try {
     const parsed = JSON.parse(init.body);
     const snaked = toSnakeCase(parsed);
@@ -643,15 +675,14 @@ function transformRequestInit(init) {
     return init;
   }
 }
+var RAW_BODY_HEADER_LOWER = RAW_BODY_HEADER.toLowerCase();
 function hasRawBodyHeader(headers) {
   if (!headers) return false;
   if (headers instanceof Headers) return headers.get(RAW_BODY_HEADER) !== null;
   if (Array.isArray(headers)) {
-    return headers.some(([name]) => name.toLowerCase() === RAW_BODY_HEADER.toLowerCase());
+    return headers.some(([name]) => name.toLowerCase() === RAW_BODY_HEADER_LOWER);
   }
-  return Object.keys(headers).some(
-    (name) => name.toLowerCase() === RAW_BODY_HEADER.toLowerCase()
-  );
+  return Object.keys(headers).some((name) => name.toLowerCase() === RAW_BODY_HEADER_LOWER);
 }
 function withoutRawBodyHeader(headers) {
   if (headers instanceof Headers) {
@@ -660,12 +691,12 @@ function withoutRawBodyHeader(headers) {
     return copy;
   }
   if (Array.isArray(headers)) {
-    return headers.filter(([name]) => name.toLowerCase() !== RAW_BODY_HEADER.toLowerCase());
+    return headers.filter(([name]) => name.toLowerCase() !== RAW_BODY_HEADER_LOWER);
   }
   if (headers) {
     const rest = {};
     for (const [name, value] of Object.entries(headers)) {
-      if (name.toLowerCase() !== RAW_BODY_HEADER.toLowerCase()) {
+      if (name.toLowerCase() !== RAW_BODY_HEADER_LOWER) {
         rest[name] = value;
       }
     }
@@ -1381,9 +1412,10 @@ var Terms = class {
    * @request GET:/api/v1/terms
    * @secure
    */
-  listTerms = (params = {}) => this.http.request({
+  listTerms = (query, params = {}) => this.http.request({
     path: `/api/v1/terms`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
@@ -1463,7 +1495,7 @@ var Inference = class {
     ...params
   });
   /**
-   * @description # TRUE HOMOICONIC API Request contains a goal term and optional constraints. Response returns solutions with term-based substitutions. ## Temporal Reasoning Use constraints to filter by temporal relations: ```json { "goal": {"sort_name": "Employment", "features": {"valid_to": {"name": "?EndTime"}}}, "constraints": [{"type": "Guard", "left": "?EndTime", "op": "lt", "right": "1583020800000"}] } ``` # Authorization Requires X-Tenant-Id header.
+   * @description # TRUE HOMOICONIC API Request contains a goal term and optional constraints. Response returns solutions with term-based substitutions. ## Temporal Reasoning Use constraints to filter by temporal relations: ```json { "goal": {"sort_name": "Employment", "features": {"valid_to": {"name": "?EndTime"}}}, "constraints": [{"type": "Guard", "left": "?EndTime", "op": "lt", "right": "1583020800000"}] } ``` # Authorization Requires X-Tenant-Id header. Traced: this is the path the zanzibar gateway hits for every permission check, so it is where an end-to-end trace either explains a slow request or does not. `skip_all` because the request body can be large and has no business in a span attribute.
    *
    * @tags inference
    * @name BackwardChain
@@ -1720,9 +1752,10 @@ var Inference = class {
    * @request GET:/api/v1/inference/facts/{tenant_id}
    * @secure
    */
-  getFacts = (tenantId, params = {}) => this.http.request({
+  getFacts = (tenantId, query, params = {}) => this.http.request({
     path: `/api/v1/inference/facts/${tenantId}`,
     method: "GET",
+    query,
     secure: true,
     format: "json",
     ...params
@@ -2612,7 +2645,7 @@ var Ingestion = class {
     ...params
   });
   /**
-   * @description POST /api/v1/ingest/document This endpoint accepts a document (as base64 or URL) and: 1. Parses it to Markdown using the document parser service (Docling) 2. Processes the Markdown through the existing ingestion pipeline 3. Returns combined statistics from both stages # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `document`: Document source (base64 or URL) - `document_type`: Optional type hint (auto-detected if not provided) - `owner_id`: User ID who owns the ingested data - `ocr_config`: Optional OCR/parsing configuration - `ingestion_config`: Optional markdown ingestion configuration # Response - `success`: Whether ingestion completed successfully - `parse_stats`: Statistics from document parsing - `metadata`: Extracted document metadata - `ingestion_stats`: Statistics from markdown ingestion - `pending_review`: Entities that need human review
+   * @description POST /api/v1/ingest/document This endpoint accepts a document (as base64 or URL) and: 1. Parses it to Markdown using the document parser service (Docling) 2. Returns the generated Markdown to the caller 3. Unless `parse_only` is true, processes the Markdown through ingestion 4. Returns combined statistics from the completed stages # Headers - `X-Tenant-Id`: Tenant ID for multi-tenancy isolation (required) # Request Body - `document`: Document source (base64 or URL) - `document_type`: Optional type hint (auto-detected if not provided) - `owner_id`: User ID who owns the ingested data - `ocr_config`: Optional OCR/parsing configuration - `ingestion_config`: Optional markdown ingestion configuration - `parse_only`: Return Markdown without creating sessions or semantic terms # Response - `success`: Whether ingestion completed successfully - `parse_stats`: Statistics from document parsing - `metadata`: Extracted document metadata - `markdown`: Markdown generated by Docling/OCR - `ingestion_stats`: Statistics from markdown ingestion - `pending_review`: Entities that need human review
    *
    * @tags ingestion
    * @name IngestDocument
@@ -2947,6 +2980,22 @@ var StructuredIngestion = class {
     format: "json",
     ...params
   });
+  /**
+   * @description The pre-registration half of #71's mode-discovery surface: a client rendering a "new source" picker learns, at type-selection time, which types registration would accept and which write-path modes each would serve — without constructing a source (postgres, for example, opens a connection pool eagerly). Static per build, so no tenant state is consulted; auth is still required, as for every route under `/api/v1`.
+   *
+   * @tags structured_ingestion
+   * @name ListSourceTypesCatalog
+   * @summary List the source types this build can register, with their mode capabilities.
+   * @request GET:/api/v1/sources/types
+   * @secure
+   */
+  listSourceTypesCatalog = (params = {}) => this.http.request({
+    path: `/api/v1/sources/types`,
+    method: "GET",
+    secure: true,
+    format: "json",
+    ...params
+  });
   /**
    * @description Creates a connector instance from the provided configuration and registers it with the structured ingestion service for subsequent schema discovery and data ingestion.
    *
@@ -12089,7 +12138,8 @@ function ProofDtoFromApiToFront(dto) {
     ruleLabel: dto.rule_label,
     substitution: HomoiconicSubstitutionDtoFromApiToFront(dto.substitution),
     subproofs: dto.subproofs?.map(ProofDtoFromApiToFront),
-    certainty: dto.certainty
+    certainty: dto.certainty,
+    residuated: dto.residuated
   };
 }
 function ProvenanceTagDtoFromApiToFront(dto) {
@@ -12105,6 +12155,7 @@ function SolutionDtoFromApiToFront(dto) {
     certainty: dto.certainty,
     evidenceMatched: dto.evidence_matched ?? void 0,
     evidenceRatio: dto.evidence_ratio ?? void 0,
+    evidenceSupport: dto.evidence_support ?? void 0,
     residuatedSorts: dto.residuated_sorts
   };
 }
@@ -12483,11 +12534,19 @@ function TaggedForwardChainResponseFromApiToFront(dto) {
     totalFacts: dto.total_facts
   };
 }
+function RuleAggregatorDtoFromFrontToApi(model) {
+  return {
+    group_by: model.groupBy,
+    op: model.op,
+    target: model.target
+  };
+}
 function AddRuleRequestFromFrontToApi(model) {
   return {
     term: TermInputDtoFromFrontToApi(model.term),
     antecedents: model.antecedents?.map(TermInputDtoFromFrontToApi),
-    certainty: model.certainty
+    certainty: model.certainty,
+    aggregator: model.aggregator ? RuleAggregatorDtoFromFrontToApi(model.aggregator) : model.aggregator
   };
 }
 function AddFactRequestFromFrontToApi(model) {
@@ -12524,7 +12583,8 @@ function ForwardChainRequestFromFrontToApi(model) {
     persist_derived: model.persistDerived,
     enable_provenance_tags: model.enableProvenanceTags,
     max_iterations: model.maxIterations,
-    max_facts: model.maxFacts
+    max_facts: model.maxFacts,
+    emit_provenance: model.emitProvenance
   };
 }
 function FuzzyProveRequestFromFrontToApi(model) {
@@ -12535,7 +12595,8 @@ function FuzzyProveRequestFromFrontToApi(model) {
     max_solutions: model.maxSolutions,
     open_world: model.openWorld,
     save_goal: model.saveGoal,
-    tnorm: model.tnorm
+    tnorm: model.tnorm,
+    scope: model.scope
   };
 }
 function BulkFuzzyProveRequestFromFrontToApi(model) {
@@ -12641,14 +12702,29 @@ var InferenceClient = class {
   /**
    * Add an inference rule.
    *
-   * @param request - Rule definition using TermInputDto.
+   * @param request - Rule definition using TermInputDto. Set `aggregator` to declare an
+   *   engine-side head aggregator (see {@link RuleAggregatorDto}).
    * @returns The created rule wrapped in an AddRuleResponse.
+   * @throws {ApiError} If the rule is rejected or the request fails.
+   *
+   * @remarks
+   * **Serialization format**: untagged `TermInputDto` / `FeatureInputValueDto`.
+   *
+   * @example
+   * ```typescript
+   * await client.inference.addRule({
+   *   term: psi('total_spend', { customer_id: Var('C'), amount: Var('A') }),
+   *   antecedents: [psi('order', { customer_id: Var('C'), amount: Var('A') })],
+   *   aggregator: { groupBy: ['customer_id'], op: 'sum', target: 'amount' },
+   * });
+   * ```
    */
   async addRule(request) {
     const wireRequest = {
       term: convertTermArg(request.term),
       antecedents: request.antecedents?.map(convertTermArg),
-      certainty: request.certainty
+      certainty: request.certainty,
+      aggregator: request.aggregator
     };
     const response = await this.api.addRule(AddRuleRequestFromFrontToApi(wireRequest));
     return AddRuleResponseFromApiToFront(response.data);
@@ -17265,6 +17341,22 @@ function CausalAnalyzeRequestFromFrontToApi(model) {
     question: CausalAnalyzeQuestionDtoFromFrontToApi(model.question)
   };
 }
+function DiDValidationRequestFromFrontToApi(model) {
+  return {
+    covariates: model.covariates,
+    outcome_post: model.outcomePost,
+    outcome_pre: model.outcomePre,
+    treatment: model.treatment
+  };
+}
+function DiDValidationResponseFromApiToFront(dto) {
+  return {
+    badControls: dto.bad_controls,
+    explanation: dto.explanation,
+    framework: dto.framework,
+    isValid: dto.is_valid
+  };
+}
 
 // src/resources/causal.ts
 var CausalClient = class {
@@ -18055,6 +18147,53 @@ var CausalClient = class {
     );
     return RefuteEstimateResponseFromApiToFront(response.data);
   }
+  // ===========================================================================
+  // Design validation
+  // ===========================================================================
+  /**
+   * Validate a Difference-in-Differences (DiD) design.
+   *
+   * @param request - The treatment variable, the pre- and post-treatment outcome
+   *   variables, and an optional conditioning set.
+   * @returns Whether the design is theoretically sound, an explanation, the bad
+   *   controls found in the conditioning set, and the framework used.
+   * @throws {BadRequestError} If the request is malformed.
+   * @throws {ApiError} If the request otherwise fails.
+   *
+   * @remarks
+   * Checks the design against the causal structure the backend builds from the
+   * tenant's homoiconic rules, using the Transformed SWIG (Delta-SWIG) framework
+   * of Knaus & Pfleiderer (2026). This is a design check over the *graph*: no
+   * sample data is submitted and nothing is estimated — validate the design here,
+   * then estimate the effect with {@link CausalClient.ateEstimate}.
+   *
+   * A design can be invalid even with an empty conditioning set (parallel trends
+   * unsupported by the structure); `badControls` names the covariates that induce
+   * bias if conditioned on, so an invalid design is often repaired by dropping
+   * them and re-validating.
+   *
+   * Plain scalar JSON — no value serialization (`ValueDto` / `FeatureValueDto`)
+   * is involved.
+   *
+   * @example
+   * ```typescript
+   * const did = await client.causal.validateDid({
+   *   treatment: 'minimum_wage_hike',
+   *   outcomePre: 'employment_2025',
+   *   outcomePost: 'employment_2026',
+   *   covariates: ['county_gdp'],
+   * });
+   * console.log(did.isValid);      // false
+   * console.log(did.badControls);  // ['county_gdp']
+   * console.log(did.framework);    // 'Delta-SWIG (Knaus & Pfleiderer, 2026)'
+   * ```
+   */
+  async validateDid(request) {
+    const response = await this.api.validateDid(
+      DiDValidationRequestFromFrontToApi(request)
+    );
+    return DiDValidationResponseFromApiToFront(response.data);
+  }
 };
 
 // src/normalizers/ingestion.ts
@@ -20963,7 +21102,8 @@ function RegisterSourceRequestFromFrontToApi(model) {
     source_id: model.sourceId,
     source_name: model.sourceName,
     source_type: model.sourceType,
-    config: model.config
+    config: model.config,
+    mode: model.mode
   };
 }
 function RegisterSourceResponseFromApiToFront(dto) {
@@ -20971,12 +21111,15 @@ function RegisterSourceResponseFromApiToFront(dto) {
     success: dto.success,
     sourceId: dto.source_id,
     sourceType: dto.source_type,
+    mode: dto.mode,
+    supportedModes: dto.supported_modes,
     message: dto.message
   };
 }
 function SourceSummaryDtoFromApiToFront(dto) {
   return {
     available: dto.available,
+    mode: dto.mode,
     sourceId: dto.source_id,
     sourceType: dto.source_type
   };
@@ -20991,7 +21134,22 @@ function SourceDetailResponseFromApiToFront(dto) {
   return {
     sourceId: dto.source_id,
     sourceType: dto.source_type,
-    available: dto.available
+    available: dto.available,
+    mode: dto.mode,
+    supportedModes: dto.supported_modes
+  };
+}
+function SourceTypeDtoFromApiToFront(dto) {
+  return {
+    sourceType: dto.source_type,
+    aliases: dto.aliases,
+    available: dto.available,
+    supportedModes: dto.supported_modes
+  };
+}
+function ListSourceTypesResponseFromApiToFront(dto) {
+  return {
+    types: dto.types.map(SourceTypeDtoFromApiToFront)
   };
 }
 function DiscoverSchemaRequestFromFrontToApi(model) {
@@ -21071,6 +21229,7 @@ function IngestFromSourceRequestFromFrontToApi(model) {
 function StructuredIngestionStatsDtoFromApiToFront(dto) {
   return {
     columnsDiscovered: dto.columns_discovered,
+    columnsDropped: dto.columns_dropped,
     documentsRendered: dto.documents_rendered,
     elapsedMs: dto.elapsed_ms,
     entitiesCreated: dto.entities_created,
@@ -21080,7 +21239,8 @@ function StructuredIngestionStatsDtoFromApiToFront(dto) {
     relationsDiscovered: dto.relations_discovered,
     sortsCreated: dto.sorts_created,
     tablesDiscovered: dto.tables_discovered,
-    termsCreated: dto.terms_created
+    termsCreated: dto.terms_created,
+    termsProjected: dto.terms_projected
   };
 }
 function IngestFromSourceResponseFromApiToFront(dto) {
@@ -21104,13 +21264,72 @@ var SourcesClient = class {
   /**
    * Register a new data source.
    *
-   * @param request - Source registration request.
-   * @returns Registration result.
+   * @param request - Source registration request. Set `mode` to declare the write-path
+   *   intent (`'transpile'` for live SQL views, `'ingest'` to materialize rows as
+   *   Ψ-term facts); omit it to take the default, which is `'ingest'` for every
+   *   source type (#71).
+   * @returns Registration result. `mode` always carries the **resolved** write-path
+   *   mode, including when the default applied; `supportedModes` advertises which
+   *   modes this source's adapter can serve.
+   * @throws {ApiError} If registration fails, with **422** if `mode` is not one of
+   *   `transpile` / `ingest`, or with **422** if `mode: 'transpile'` is requested
+   *   for a source whose adapter cannot execute transpiled SQL (a live view over it
+   *   could never be queried).
+   *
+   * @remarks
+   * Registering with `mode: 'transpile'` makes {@link SourcesClient.ingest} refuse this
+   * source with a **409** — materializing a transpiled source would create a second,
+   * divergent namespace over the same rows. To learn which types accept `transpile`
+   * before registering, call {@link SourcesClient.listSourceTypes}.
+   *
+   * @example
+   * ```typescript
+   * const result = await client.sources.register({
+   *   sourceId: 'crm_postgres',
+   *   sourceName: 'CRM PostgreSQL',
+   *   sourceType: 'postgres',
+   *   config: { connection_string: 'postgres://user:pass@host/db' },
+   *   mode: 'ingest',
+   * });
+   * console.log(result.mode); // 'ingest'
+   * console.log(result.supportedModes); // ['ingest', 'transpile']
+   * ```
    */
   async register(request) {
     const response = await this.api.registerSource(RegisterSourceRequestFromFrontToApi(request));
     return RegisterSourceResponseFromApiToFront(response.data);
   }
+  /**
+   * List the source types this build can register, with their mode capabilities.
+   *
+   * @returns Every registrable source type, its availability in this build, and the
+   *   write-path modes each would serve — before any source exists.
+   * @throws {ApiError} If the request fails.
+   *
+   * @remarks
+   * Sent to `GET /api/v1/sources/types`. The pre-registration half of #71's
+   * mode-discovery surface: a client rendering a "new source" picker learns, at
+   * type-selection time, which types registration would accept (`available` — a
+   * type behind an uncompiled cargo feature is `false`) and which modes each
+   * would serve (`supportedModes` — always `'ingest'`, plus `'transpile'` only
+   * for the SQL engines). Static per build, so no tenant state is consulted.
+   *
+   * Drive a mode selector from `supportedModes` rather than a hard-coded list of
+   * source types: the set is the adapter's declared capability, so it stays
+   * correct as adapters gain the ability (MySQL and SQLite did in #70).
+   *
+   * @example
+   * ```typescript
+   * const { types } = await client.sources.listSourceTypes();
+   * const postgres = types.find((t) => t.sourceType === 'postgres');
+   * console.log(postgres?.supportedModes); // ['ingest', 'transpile']
+   * console.log(postgres?.aliases); // ['postgresql']
+   * ```
+   */
+  async listSourceTypes() {
+    const response = await this.api.listSourceTypesCatalog();
+    return ListSourceTypesResponseFromApiToFront(response.data);
+  }
   /**
    * List all registered data sources.
    *
@@ -22281,13 +22500,35 @@ function mapEntity(e) {
     sourceText: e.source_text ?? null
   };
 }
+function toRuleSeverity(severity) {
+  switch (severity) {
+    case "critical":
+    case "major":
+    case "minor":
+    case "informational":
+      return severity;
+    default:
+      return "informational";
+  }
+}
+function toRuleStatus(status) {
+  switch (status) {
+    case "pass":
+    case "fail":
+    case "inconclusive":
+    case "not_applicable":
+      return status;
+    default:
+      return "inconclusive";
+  }
+}
 function mapRuleResult(r) {
   return {
     ruleId: r.rule_id ?? "",
     ruleDescription: r.rule_description ?? "",
     ruleSort: r.rule_sort ?? "",
-    severity: r.severity ?? "informational",
-    status: r.status ?? "inconclusive",
+    severity: toRuleSeverity(r.severity),
+    status: toRuleStatus(r.status),
     confidence: r.confidence ?? 0,
     evidence: r.evidence ?? [],
     proofTrace: r.proof_trace ? r.proof_trace.map(mapProofStep) : null,
@@ -26537,11 +26778,112 @@ var FlowNetworksClient = class {
 };
 
 // src/normalizers/osfql.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function OsfqlValueFromApiToFront(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const payload = value["value"];
+  switch (value["type"]) {
+    case "null":
+      return { type: "null" };
+    case "integer":
+      return typeof payload === "number" ? { type: "integer", value: payload } : void 0;
+    case "float":
+      return typeof payload === "number" ? { type: "float", value: payload } : void 0;
+    case "string":
+      return typeof payload === "string" ? { type: "string", value: payload } : void 0;
+    case "boolean":
+      return typeof payload === "boolean" ? { type: "boolean", value: payload } : void 0;
+    case "term_ref":
+      return typeof payload === "string" ? { type: "term_ref", value: payload } : void 0;
+    case "list": {
+      if (!Array.isArray(payload)) {
+        return void 0;
+      }
+      const items = payload;
+      const parsed = [];
+      for (const item of items) {
+        const element = OsfqlValueFromApiToFront(item);
+        if (element === void 0) {
+          return void 0;
+        }
+        parsed.push(element);
+      }
+      return { type: "list", value: parsed };
+    }
+    case "term": {
+      const term = OsfqlTermValueFromApiToFront(payload);
+      return term === void 0 ? void 0 : { type: "term", value: term };
+    }
+    default:
+      return void 0;
+  }
+}
+function OsfqlTermValueFromApiToFront(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const sort = value["sort"];
+  if (typeof sort !== "string") {
+    return void 0;
+  }
+  const features = OsfqlBindingFromApiToFront(value["features"]);
+  return features === void 0 ? void 0 : { sort, features };
+}
+function OsfqlBindingFromApiToFront(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const out = {};
+  for (const [name, raw] of Object.entries(value)) {
+    const parsed = OsfqlValueFromApiToFront(raw);
+    if (parsed === void 0) {
+      return void 0;
+    }
+    out[name] = parsed;
+  }
+  return out;
+}
+function OsfqlBindingsFromApiToFront(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const rows = value;
+  const out = [];
+  for (const row of rows) {
+    const parsed = OsfqlBindingFromApiToFront(row);
+    if (parsed === void 0) {
+      return void 0;
+    }
+    out.push(parsed);
+  }
+  return out;
+}
+function OsfqlRequestFromFrontToApi(model) {
+  return {
+    query: model.query,
+    reactive: model.reactive
+  };
+}
 function OsfqlResponseFromApiToFront(dto) {
+  const bindings = OsfqlBindingsFromApiToFront(dto.bindings);
+  if (bindings === void 0) {
+    return void 0;
+  }
+  let fetched;
+  if (dto.fetched !== void 0 && dto.fetched !== null) {
+    fetched = OsfqlBindingsFromApiToFront(dto.fetched);
+    if (fetched === void 0) {
+      return void 0;
+    }
+  }
   return {
     success: dto.success,
-    bindings: dto.bindings,
-    fetched: dto.fetched,
+    bindings,
+    fetched,
     producedTermIds: dto.produced_term_ids,
     definedSortIds: dto.defined_sort_ids,
     diagnostics: dto.diagnostics,
@@ -26587,15 +26929,28 @@ var OsfqlClient = class {
    * Execute an OSFQL program.
    *
    * @param query - The OSFQL program text (one or more statements separated by `;`).
+   * @param options - Optional execution options. Set `reactive` to fire suspended
+   *   `AWAIT` demons whose triggers the program has just satisfied.
    * @returns The execution result including variable bindings, produced term IDs,
    *   defined sort IDs, diagnostics, and statement count.
    * @throws {ApiError} If the request fails.
+   * @throws {ReasoningLayerError} If the server returns bindings that do not satisfy the
+   *   published {@link OsfqlValue} contract.
    *
    * @remarks
    * The query is parsed, compiled, and executed against the caller's tenant-isolated
    * knowledge base. Results include variable bindings from MATCH queries and IDs of
    * any terms or sorts created by INSERT, DERIVE, or DEFINE statements.
    *
+   * Bindings use the **tagged** {@link OsfqlValue} format with lowercase `type`
+   * discriminators — not the PascalCase `ValueDto` term-CRUD format.
+   *
+   * `reactive` opts into **reactive (streaming) mode**: once the program has run,
+   * any suspended `AWAIT` demon whose trigger is now satisfied fires
+   * automatically, with no explicit `RELEASE RESIDUATIONS` statement. It defaults
+   * to `false` — demons stay suspended until an explicit RELEASE — so omitting it
+   * leaves the request byte-identical to before.
+   *
    * @example
    * ```typescript
    * // Insert a record and query it back
@@ -26606,11 +26961,27 @@ var OsfqlClient = class {
    * console.log(result.bindings);         // [{ N: { type: "string", value: "Alice" } }]
    * console.log(result.producedTermIds);  // ["<uuid>"]
    * console.log(result.statementCount);   // 2
+   *
+   * // Let an AWAIT demon fire as soon as its trigger is satisfied
+   * await client.osfql.execute('AWAIT person(name: "Bob");');
+   * const reactive = await client.osfql.execute(
+   *   'INSERT person(name: "Bob", age: 41);',
+   *   { reactive: true },
+   * );
+   * console.log(reactive.producedTermIds); // includes the demon's own output
    * ```
    */
-  async execute(query) {
-    const response = await this.api.executeOsfql({ query });
-    return OsfqlResponseFromApiToFront(response.data);
+  async execute(query, options) {
+    const response = await this.api.executeOsfql(
+      OsfqlRequestFromFrontToApi({ query, reactive: options?.reactive })
+    );
+    const parsed = OsfqlResponseFromApiToFront(response.data);
+    if (parsed === void 0) {
+      throw new ReasoningLayerError(
+        "osfql/execute returned bindings that do not match the published OsfqlValue contract (expected tagged values with a lowercase `type` discriminator)"
+      );
+    }
+    return parsed;
   }
   /**
    * Diagnose an OSFQL program for contradictions and inconsistencies.
@@ -26697,7 +27068,9 @@ function ConversationMessageRequestFromFrontToApi(model) {
     conversation_id: model.conversationId,
     session_id: model.sessionId,
     current_sort_context: model.currentSortContext,
-    generate_certificate: model.generateCertificate
+    generate_certificate: model.generateCertificate,
+    constrained_decode: model.constrainedDecode,
+    model: model.model
   };
 }
 function DerivationSummaryDtoFromApiToFront(dto) {
@@ -26805,7 +27178,12 @@ function ConversationMessageResponseFromApiToFront(dto) {
     cognitiveStrategy: dto.cognitive_strategy ? CognitiveStrategyDtoFromApiToFront(dto.cognitive_strategy) : void 0,
     reasoningTrace: dto.reasoning_trace ? ReasoningTraceDtoFromApiToFront(dto.reasoning_trace) : void 0,
     validityCertificateHash: dto.validity_certificate_hash ?? void 0,
-    validityCertificateId: dto.validity_certificate_id ?? void 0
+    validityCertificateId: dto.validity_certificate_id ?? void 0,
+    validityCertificateRuleProgramHash: dto.validity_certificate_rule_program_hash ?? void 0,
+    validityCertificateRuleRevision: dto.validity_certificate_rule_revision ?? void 0,
+    modelId: dto.model_id ?? void 0,
+    prefillMs: dto.prefill_ms ?? void 0,
+    tokensPerSec: dto.tokens_per_sec ?? void 0
   };
 }
 function TurnDtoFromApiToFront(dto) {
@@ -30651,12 +31029,16 @@ function PropertyGraphQueryRequestFromFrontToApi(model) {
   };
 }
 function PropertyGraphExecuteResponseFromApiToFront(dto) {
+  const bindings = OsfqlBindingsFromApiToFront(dto.bindings);
+  if (bindings === void 0) {
+    return void 0;
+  }
   return {
     success: dto.success,
     language: dto.language,
     operation: dto.operation,
     osfql: dto.osfql,
-    bindings: dto.bindings,
+    bindings,
     producedTermIds: dto.produced_term_ids,
     definedSortIds: dto.defined_sort_ids,
     diagnostics: dto.diagnostics,
@@ -30674,13 +31056,27 @@ function PropertyGraphTranslateResponseFromApiToFront(dto) {
 }
 
 // src/resources/property-graph.ts
-var PropertyGraphClient = class {
+var PropertyGraphClient = class _PropertyGraphClient {
   /** @internal */
   api;
   /** @internal */
   constructor(api) {
     this.api = api;
   }
+  /**
+   * Parse an execution response, failing loudly on a contract violation.
+   *
+   * @internal
+   */
+  static parseExecuteResponse(dto) {
+    const parsed = PropertyGraphExecuteResponseFromApiToFront(dto);
+    if (parsed === void 0) {
+      throw new ReasoningLayerError(
+        "the property-graph endpoint returned bindings that do not match the published PropertyGraphValue contract (expected tagged values with a lowercase `type` discriminator)"
+      );
+    }
+    return parsed;
+  }
   /**
    * Execute a Cypher query.
    *
@@ -30688,6 +31084,8 @@ var PropertyGraphClient = class {
    * @returns Execution result: bindings, the OSFQL program that ran, produced term IDs,
    *   defined sort IDs, diagnostics, compatibility notes, and the statement count.
    * @throws {ApiError} If the query cannot be parsed, cannot be lowered to OSFQL, or fails to execute.
+   * @throws {ReasoningLayerError} If the server returns bindings that do not satisfy the
+   *   published {@link PropertyGraphValue} contract.
    *
    * @remarks
    * The query is parsed as Cypher, lowered to OSFQL, and executed against the
@@ -30707,7 +31105,7 @@ var PropertyGraphClient = class {
     const response = await this.api.executeCypherPost(
       PropertyGraphQueryRequestFromFrontToApi({ query })
     );
-    return PropertyGraphExecuteResponseFromApiToFront(response.data);
+    return _PropertyGraphClient.parseExecuteResponse(response.data);
   }
   /**
    * Execute a GQL (ISO/IEC 39075) query.
@@ -30716,6 +31114,8 @@ var PropertyGraphClient = class {
    * @returns Execution result: bindings, the OSFQL program that ran, produced term IDs,
    *   defined sort IDs, diagnostics, compatibility notes, and the statement count.
    * @throws {ApiError} If the query cannot be parsed, cannot be lowered to OSFQL, or fails to execute.
+   * @throws {ReasoningLayerError} If the server returns bindings that do not satisfy the
+   *   published {@link PropertyGraphValue} contract.
    *
    * @remarks
    * The query is parsed as GQL, lowered to OSFQL, and executed against the
@@ -30735,7 +31135,7 @@ var PropertyGraphClient = class {
     const response = await this.api.executeGqlPost(
       PropertyGraphQueryRequestFromFrontToApi({ query })
     );
-    return PropertyGraphExecuteResponseFromApiToFront(response.data);
+    return _PropertyGraphClient.parseExecuteResponse(response.data);
   }
   /**
    * Execute a Gremlin traversal.
@@ -30744,6 +31144,8 @@ var PropertyGraphClient = class {
    * @returns Execution result: bindings, the OSFQL program that ran, produced term IDs,
    *   defined sort IDs, diagnostics, compatibility notes, and the statement count.
    * @throws {ApiError} If the traversal cannot be parsed, cannot be lowered to OSFQL, or fails to execute.
+   * @throws {ReasoningLayerError} If the server returns bindings that do not satisfy the
+   *   published {@link PropertyGraphValue} contract.
    *
    * @remarks
    * The traversal is parsed as Gremlin, lowered to OSFQL, and executed against the
@@ -30762,7 +31164,7 @@ var PropertyGraphClient = class {
     const response = await this.api.executeGremlinPost(
       PropertyGraphQueryRequestFromFrontToApi({ query })
     );
-    return PropertyGraphExecuteResponseFromApiToFront(response.data);
+    return _PropertyGraphClient.parseExecuteResponse(response.data);
   }
   /**
    * Translate a Cypher query to OSFQL without executing it.
@@ -30848,14 +31250,14 @@ var PropertyGraphClient = class {
 };
 
 // src/normalizers/sparql.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isString(value) {
   return typeof value === "string";
 }
 function headVars(head) {
-  if (!isRecord(head)) {
+  if (!isRecord2(head)) {
     throw new Error('Malformed SPARQL results: "head" is not an object');
   }
   const vars = head["vars"];
@@ -30868,7 +31270,7 @@ function headVars(head) {
   return vars;
 }
 function SparqlRdfTermFromApiToFront(raw) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error("Malformed SPARQL results: a solution binding is not an object");
   }
   const termType = raw["type"];
@@ -30893,7 +31295,7 @@ function SparqlRdfTermFromApiToFront(raw) {
     };
   }
   if (termType === "triple") {
-    if (!isRecord(value)) {
+    if (!isRecord2(value)) {
       throw new Error('Malformed SPARQL results: "triple" binding has a non-object value');
     }
     return {
@@ -30910,7 +31312,7 @@ function SparqlRdfTermFromApiToFront(raw) {
   );
 }
 function SparqlBindingSetFromApiToFront(raw) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error("Malformed SPARQL results: a solution is not an object");
   }
   const bindings = {};
@@ -30920,7 +31322,7 @@ function SparqlBindingSetFromApiToFront(raw) {
   return bindings;
 }
 function bindingsFromResultSet(results) {
-  if (!isRecord(results)) {
+  if (!isRecord2(results)) {
     throw new Error('Malformed SPARQL results: "results" is not an object');
   }
   const bindings = results["bindings"];
@@ -30952,7 +31354,7 @@ function SparqlEntailmentRegimeFromApiToFront(entailment) {
   }
 }
 function SparqlQueryResultsFromApiToFront(raw) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error(
       "Malformed SPARQL results: the response body is not a SPARQL 1.1 Query Results JSON document (a CONSTRUCT or DESCRIBE query answers with an RDF graph document instead)"
     );
@@ -30979,7 +31381,7 @@ function GraphSparqlQueryRequestFromFrontToApi(model) {
   };
 }
 function GraphSparqlResultsFromApiToFront(raw) {
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     throw new Error(
       "Malformed SPARQL results: the co-located store response is not a SPARQL 1.1 Query Results JSON document"
     );
@@ -31267,6 +31669,38 @@ var SparqlClient = class {
 };
 
 // src/normalizers/osf-diff.ts
+function TermSetSelectorFromFrontToApi(selector) {
+  switch (selector.type) {
+    case "document":
+      return { type: "document", document_id: selector.documentId };
+    case "document_version":
+      return { type: "document_version", document_id: selector.documentId };
+    case "collection":
+      return { type: "collection", path: selector.path };
+    case "term_ids":
+      return { type: "term_ids", ids: selector.ids };
+    case "sort":
+      return {
+        type: "sort",
+        sort_name: selector.sortName,
+        include_descendants: selector.includeDescendants
+      };
+    case "query":
+      return { type: "query", osfql: selector.osfql };
+    case "snapshot":
+      return {
+        type: "snapshot",
+        snapshot_id: selector.snapshotId,
+        filter: selector.filter === void 0 ? void 0 : TermSetSelectorFromFrontToApi(selector.filter)
+      };
+    case "as_of":
+      return {
+        type: "as_of",
+        at: selector.at,
+        filter: selector.filter === void 0 ? void 0 : TermSetSelectorFromFrontToApi(selector.filter)
+      };
+  }
+}
 function TemporalPointFromFrontToApi(model) {
   return {
     at: model.at,
@@ -31275,8 +31709,8 @@ function TemporalPointFromFrontToApi(model) {
 }
 function OsfDiffRequestFromFrontToApi(model) {
   return {
-    a: model.a,
-    b: model.b,
+    a: TermSetSelectorFromFrontToApi(model.a),
+    b: TermSetSelectorFromFrontToApi(model.b),
     include_clause_diff: model.includeClauseDiff,
     include_entity_diff: model.includeEntityDiff,
     threshold: model.threshold
@@ -31290,7 +31724,7 @@ function OsfDiffResponseFromApiToFront(dto) {
 function OsfDiffSequenceRequestFromFrontToApi(model) {
   return {
     document_family_id: model.documentFamilyId,
-    selectors: model.selectors,
+    selectors: model.selectors?.map(TermSetSelectorFromFrontToApi),
     threshold: model.threshold
   };
 }
@@ -31301,7 +31735,7 @@ function OsfDiffSequenceResponseFromApiToFront(dto) {
 }
 function OsfDiffTemporalRequestFromFrontToApi(model) {
   return {
-    filter: model.filter,
+    filter: model.filter === void 0 ? void 0 : TermSetSelectorFromFrontToApi(model.filter),
     from: TemporalPointFromFrontToApi(model.from),
     to: TemporalPointFromFrontToApi(model.to),
     threshold: model.threshold
@@ -31336,13 +31770,14 @@ var OsfDiffClient = class {
    * Entities are matched by OSF unification; `threshold` (default 0.7) is the
    * minimum match degree at which two entities are considered the same. Set
    * `includeClauseDiff` / `includeEntityDiff` to control which deltas the report
-   * carries. Selectors and the report are opaque wire-format JSON objects.
+   * carries. Each side is a typed {@link OsfDiffSelector}; the report is an opaque
+   * wire-format JSON object.
    *
    * @example
    * ```typescript
    * const result = await client.osfDiff.diff({
-   *   a: { type: 'document', document_id: 'a1b2c3d4-...' },
-   *   b: { type: 'document', document_id: 'e5f6a7b8-...' },
+   *   a: { type: 'document', documentId: 'a1b2c3d4-...' },
+   *   b: { type: 'document', documentId: 'e5f6a7b8-...' },
    *   includeClauseDiff: true,
    *   threshold: 0.8,
    * });
@@ -31402,7 +31837,7 @@ var OsfDiffClient = class {
    * const result = await client.osfDiff.diffTemporal({
    *   from: { at: '2026-01-01T00:00:00Z' },
    *   to: {},  // live
-   *   filter: { type: 'document', document_id: 'a1b2c3d4-...' },
+   *   filter: { type: 'document', documentId: 'a1b2c3d4-...' },
    * });
    * console.log(result.report);
    * ```
@@ -31775,13 +32210,22 @@ function SatSolverStatsDtoFromApiToFront(dto) {
 }
 function modelFromApiToFront(raw) {
   if (!Array.isArray(raw)) {
-    return [];
+    throw new ValidationError(
+      "SAT solver returned a 'satisfiable' verdict without a model; the endpoint contract requires one. Refusing to report an assignment the solver did not give.",
+      "model"
+    );
   }
+  const entries = raw;
   const model = [];
-  for (const entry of raw) {
-    if (typeof entry === "boolean") {
-      model.push(entry);
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (typeof entry !== "boolean") {
+      throw new ValidationError(
+        `SAT model entry at index ${index} is ${typeof entry}, not a Boolean. The assignment vector is positional, so this entry cannot be dropped without corrupting every later variable.`,
+        "model"
+      );
     }
+    model.push(entry);
   }
   return model;
 }
@@ -31832,12 +32276,19 @@ var SatClient = class {
    *   Solver statistics are attached to every branch.
    * @throws {ApiError} If the request fails (e.g. a literal references a variable
    *   index `>= numVars`, or a clause is empty).
+   * @throws {ValidationError} If a `satisfiable` verdict arrives without a
+   *   well-formed Boolean model, which violates the endpoint contract.
    *
    * @remarks
    * Narrow on `result` to reach the model — it exists only on the `satisfiable`
    * branch. `maxConflicts: 0` (the default) means an unlimited budget, in which
    * case `unknown` cannot be returned.
    *
+   * The model is index-aligned with the variables (`model[i]` is the value of
+   * variable `i`). A `satisfiable` response whose model is missing or holds a
+   * non-Boolean is reported as a {@link ValidationError} rather than silently
+   * shortened — dropping an entry would shift every later variable's assignment.
+   *
    * Plain JSON serialization: literals are `{ var, negated }` objects and the
    * model is a `boolean[]` indexed by variable number. No tagged `ValueDto` or
    * untagged `FeatureValueDto` encoding is used.
@@ -31889,12 +32340,12 @@ function EqLiteralDtoFromFrontToApi(model) {
     negated: model.negated
   };
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function assignmentsFromApiToFront(raw) {
   const assignments = {};
-  if (!isRecord2(raw)) {
+  if (!isRecord3(raw)) {
     return assignments;
   }
   for (const [key, value] of Object.entries(raw)) {
@@ -32096,7 +32547,9 @@ var ChaseClient = class {
    * ```
    */
   async run(request) {
-    const response = await this.api.runChase(ChaseRunRequestFromFrontToApi(request));
+    const response = await this.api.runChase(ChaseRunRequestFromFrontToApi(request), {
+      headers: { [RAW_BODY_HEADER]: "1" }
+    });
     return ChaseRunResponseFromApiToFront(response.data);
   }
 };
@@ -32226,7 +32679,7 @@ var ConformanceClient = class {
 };
 
 // src/normalizers/temporal.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asNumber(value) {
@@ -32286,38 +32739,6 @@ function TemporalModelCheckResponseFromApiToFront(dto) {
     counterexample
   };
 }
-function TermSetSelectorFromFrontToApi(selector) {
-  switch (selector.type) {
-    case "document":
-      return { type: "document", document_id: selector.documentId };
-    case "document_version":
-      return { type: "document_version", document_id: selector.documentId };
-    case "collection":
-      return { type: "collection", path: selector.path };
-    case "term_ids":
-      return { type: "term_ids", ids: selector.ids };
-    case "sort":
-      return {
-        type: "sort",
-        sort_name: selector.sortName,
-        include_descendants: selector.includeDescendants
-      };
-    case "query":
-      return { type: "query", osfql: selector.osfql };
-    case "snapshot":
-      return {
-        type: "snapshot",
-        snapshot_id: selector.snapshotId,
-        filter: selector.filter === void 0 ? void 0 : TermSetSelectorFromFrontToApi(selector.filter)
-      };
-    case "as_of":
-      return {
-        type: "as_of",
-        at: selector.at,
-        filter: selector.filter === void 0 ? void 0 : TermSetSelectorFromFrontToApi(selector.filter)
-      };
-  }
-}
 function TemporalSeriesSpecFromFrontToApi(spec) {
   const time = spec.time.kind === "date_time_feature" ? { kind: "date_time_feature", name: spec.time.name } : { kind: "epoch_feature", name: spec.time.name, unit: spec.time.unit };
   const value = spec.value.kind === "feature" ? { kind: "feature", name: spec.value.name } : { kind: "count" };
@@ -32354,7 +32775,7 @@ function TemporalSeriesRequestFromFrontToApi(model) {
   };
 }
 function TemporalSeriesPointFromApiToFront(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return void 0;
   }
   const bucketStart = asNumber(value["bucket_start"]);
@@ -32372,7 +32793,7 @@ function TemporalSeriesPointFromApiToFront(value) {
   };
 }
 function TemporalTrendSummaryFromApiToFront(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return void 0;
   }
   const slopePerMs = asNumber(value["slope_per_ms"]);
@@ -32387,7 +32808,7 @@ function TemporalTrendSummaryFromApiToFront(value) {
   return { slopePerMs, intercept, first, last, delta, n };
 }
 function TemporalSeriesFromApiToFront(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return void 0;
   }
   const rawPoints = value["points"];
@@ -32534,7 +32955,7 @@ var TemporalClient = class {
 };
 
 // src/normalizers/forecast.ts
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function asNumber2(value) {
@@ -32587,7 +33008,7 @@ function ForecastRequestFromFrontToApi(model) {
   };
 }
 function CompetitorForecastFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const id = asString(value["id"]);
@@ -32599,7 +33020,7 @@ function CompetitorForecastFromApiToFront(value) {
   return { id, pWin, pTopK };
 }
 function OrderedComboFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const members = asStringArray(value["members"]);
@@ -32610,7 +33031,7 @@ function OrderedComboFromApiToFront(value) {
   return { members, probability };
 }
 function ForecastCoveringSetFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const members = asStringArray(value["members"]);
@@ -32623,7 +33044,7 @@ function ForecastCoveringSetFromApiToFront(value) {
   return { members, alpha, slice, sliceFallback };
 }
 function RankedInstrumentFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const id = asString(value["id"]);
@@ -32643,7 +33064,7 @@ function RankedInstrumentFromApiToFront(value) {
   return { id, score, rank, interval };
 }
 function ForecastBodyFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const shape = value["shape"];
@@ -32697,7 +33118,7 @@ function ForecastBodyFromApiToFront(value) {
   return void 0;
 }
 function ForecastCertificateFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const modelFingerprint = asString(value["model_fingerprint"]);
@@ -32716,7 +33137,7 @@ function ForecastCertificateFromApiToFront(value) {
   };
 }
 function CertifiedForecastFromApiToFront(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
   const outcome = value["outcome"];
@@ -32993,7 +33414,9 @@ var DlClient = class {
    * ```
    */
   async satisfiable(request) {
-    const response = await this.api.satisfiable(DlSatisfiableRequestFromFrontToApi(request));
+    const response = await this.api.satisfiable(DlSatisfiableRequestFromFrontToApi(request), {
+      headers: { [RAW_BODY_HEADER]: "1" }
+    });
     return DlSatisfiableResponseFromApiToFront(response.data);
   }
   /**
@@ -33029,7 +33452,9 @@ var DlClient = class {
    * ```
    */
   async subsumes(request) {
-    const response = await this.api.subsumes(DlSubsumesRequestFromFrontToApi(request));
+    const response = await this.api.subsumes(DlSubsumesRequestFromFrontToApi(request), {
+      headers: { [RAW_BODY_HEADER]: "1" }
+    });
     return DlSubsumesResponseFromApiToFront(response.data);
   }
 };
@@ -33786,21 +34211,50 @@ var OntologyExportClient = class {
   constructor(api) {
     this.api = api;
   }
+  /**
+   * Issue a content-negotiated export request and project the response.
+   *
+   * @internal
+   * @remarks
+   * Goes through the transport directly rather than through the generated route
+   * methods: `root` is repeatable server-side (`?root=a&root=b`), but utoipa
+   * cannot express a repeated query parameter, so the generated routes type it as
+   * a lone `root?: string` — narrower than the endpoint each route's own
+   * "(repeatable)" doc comment describes. The transport's query serializer
+   * already branches on `Array.isArray` and emits the repeats correctly.
+   */
+  async requestExport(path, options) {
+    const response = await this.api.http.request({
+      path,
+      method: "GET",
+      query: OntologyExportQueryFromFrontToApi(options),
+      secure: true,
+      headers: { Accept: OntologyExportAcceptFromFrontToApi(options?.format) }
+    });
+    const document = await response.text();
+    return OntologyExportDocumentFromApiToFront(
+      response.headers.get("content-type"),
+      document
+    );
+  }
   /**
    * Export the tenant's sort lattice (or a sub-lattice) as an OWL ontology.
    *
    * @param options - Export options: the base IRI for synthesized IRIs, the root
-   *   sort to restrict the export to, and the serialization to negotiate on.
+   *   sort (or sorts) to restrict the export to, and the serialization to
+   *   negotiate on.
    * @returns The exported document, verbatim, with the media type the server
    *   answered with.
    * @throws {BadRequestError} If the base IRI is invalid or the query is malformed.
-   * @throws {NotFoundError} If the requested root sort does not exist.
+   * @throws {NotFoundError} If a requested root sort does not exist.
    * @throws {ApiError} If the request otherwise fails.
    *
    * @remarks
    * Omit `root` to export the whole tenant schema. Omit `base` to let the backend
    * synthesize IRIs under `urn:osfkb:tenant:{tenant_id}`.
    *
+   * `root` is repeatable: pass an array to export several sub-lattices at once.
+   *
    * `format` selects the `Accept` header: an RDF serialization yields an RDF
    * document, and the default (`'json'`) yields the backend's JSON rendering as
    * JSON text — parse it with `JSON.parse` when you need the object.
@@ -33813,36 +34267,35 @@ var OntologyExportClient = class {
    *   format: 'turtle',
    * });
    *
-   * console.log(owl.contentType); // 'text/turtle'
+   * console.log(owl.contentType); // 'text/turtle; charset=utf-8'
    * console.log(owl.document);    // '@prefix : <https://example.org/ontology#> ...'
+   *
+   * // Several sub-lattices in one export -> ?root=clinical_entity&root=administrative_entity
+   * const both = await client.ontologyExport.exportOwl({
+   *   root: ['clinical_entity', 'administrative_entity'],
+   * });
    * ```
    */
   async exportOwl(options) {
-    const response = await this.api.exportOntologyOwl(
-      OntologyExportQueryFromFrontToApi(options),
-      { headers: { Accept: OntologyExportAcceptFromFrontToApi(options?.format) } }
-    );
-    const document = await response.text();
-    return OntologyExportDocumentFromApiToFront(
-      response.headers.get("content-type"),
-      document
-    );
+    return this.requestExport("/api/v1/ontology/export/owl", options);
   }
   /**
    * Export the tenant's schema constraints (or those of a sub-lattice) as SHACL
    * shapes.
    *
    * @param options - Export options: the base IRI for synthesized IRIs, the root
-   *   sort to restrict the export to, and the serialization to negotiate on.
+   *   sort (or sorts) to restrict the export to, and the serialization to
+   *   negotiate on.
    * @returns The exported document, verbatim, with the media type the server
    *   answered with.
    * @throws {BadRequestError} If the base IRI is invalid or the query is malformed.
-   * @throws {NotFoundError} If the requested root sort does not exist.
+   * @throws {NotFoundError} If a requested root sort does not exist.
    * @throws {ApiError} If the request otherwise fails.
    *
    * @remarks
    * Each exported shape targets one sort and constrains its features. Omit `root`
-   * to export the whole tenant schema.
+   * to export the whole tenant schema; pass an array to export the shapes of
+   * several sub-lattices at once.
    *
    * `format` selects the `Accept` header: an RDF serialization yields an RDF
    * document, and the default (`'json'`) yields the backend's JSON rendering of
@@ -33852,20 +34305,12 @@ var OntologyExportClient = class {
    * ```typescript
    * const shacl = await client.ontologyExport.exportShacl({ format: 'turtle' });
    *
-   * console.log(shacl.contentType); // 'text/turtle'
+   * console.log(shacl.contentType); // 'text/turtle; charset=utf-8'
    * console.log(shacl.document);    // '... sh:NodeShape ...'
    * ```
    */
   async exportShacl(options) {
-    const response = await this.api.exportOntologyShacl(
-      OntologyExportQueryFromFrontToApi(options),
-      { headers: { Accept: OntologyExportAcceptFromFrontToApi(options?.format) } }
-    );
-    const document = await response.text();
-    return OntologyExportDocumentFromApiToFront(
-      response.headers.get("content-type"),
-      document
-    );
+    return this.requestExport("/api/v1/ontology/export/shacl", options);
   }
 };