@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-NJSYWX7H.js

@@ -0,0 +1,190 @@
+// src/plugin-solver-contract/PluginSolverContract.ts
+var PluginSolverContractRegistry = class {
+  constructor() {
+    this.contracts = /* @__PURE__ */ new Map();
+    this.evaluators = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a solver contract declaration.
+   *
+   * @throws If a contract with the same `id` is already registered by a
+   *         different plugin.
+   */
+  registerContract(contract) {
+    const existing = this.contracts.get(contract.id);
+    if (existing) {
+      if (existing.pluginId === contract.pluginId) return;
+      throw new Error(
+        `[PluginSolverContractRegistry] Contract "${contract.id}" already registered by plugin "${existing.pluginId}". Cannot re-register from "${contract.pluginId}".`
+      );
+    }
+    this.contracts.set(contract.id, contract);
+  }
+  /**
+   * Register a clause evaluator function for a specific clause within a contract.
+   *
+   * @param contractId  The contract's `id`.
+   * @param clauseId    The clause's `id` within that contract.
+   * @param evaluator   Returns true when the clause holds.
+   */
+  registerEvaluator(contractId, clauseId, evaluator) {
+    if (!this.evaluators.has(contractId)) {
+      this.evaluators.set(contractId, /* @__PURE__ */ new Map());
+    }
+    this.evaluators.get(contractId).set(clauseId, evaluator);
+  }
+  /** Look up a registered contract by id. Returns undefined if not found. */
+  getContract(id) {
+    return this.contracts.get(id);
+  }
+  /** Look up a clause evaluator. Returns undefined if not registered. */
+  getEvaluator(contractId, clauseId) {
+    return this.evaluators.get(contractId)?.get(clauseId);
+  }
+  /** All registered contracts (for introspection). */
+  allContracts() {
+    return [...this.contracts.values()];
+  }
+  /** Count of registered contracts. */
+  get size() {
+    return this.contracts.size;
+  }
+};
+var SolverReceiptSchemaRegistry = class {
+  constructor() {
+    this.schemas = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a receipt schema.
+   *
+   * @throws If a schema with the same `id` is registered by a different plugin.
+   */
+  registerSchema(entry) {
+    const existing = this.schemas.get(entry.id);
+    if (existing) {
+      if (existing.pluginId === entry.pluginId) return;
+      throw new Error(
+        `[SolverReceiptSchemaRegistry] Schema "${entry.id}" already registered by "${existing.pluginId}". Cannot re-register from "${entry.pluginId}".`
+      );
+    }
+    this.schemas.set(entry.id, entry);
+  }
+  /** Look up a schema by id. Returns undefined → caller labels receipt freeform. */
+  getSchema(id) {
+    return this.schemas.get(id);
+  }
+  /**
+   * Validate `result` against the schema registered under `schemaId`.
+   * Returns `null` if no schema is registered (freeform).
+   */
+  validate(schemaId, result) {
+    const schema = this.schemas.get(schemaId);
+    if (!schema) return null;
+    return schema.validate(result);
+  }
+  /** All registered schemas (for introspection). */
+  allSchemas() {
+    return [...this.schemas.values()];
+  }
+  /** Count of registered schemas. */
+  get size() {
+    return this.schemas.size;
+  }
+};
+var globalContractRegistry = new PluginSolverContractRegistry();
+var globalSchemaRegistry = new SolverReceiptSchemaRegistry();
+function registerPluginContract(contract) {
+  globalContractRegistry.registerContract(contract);
+}
+function registerContractClauseEvaluator(contractId, clauseId, evaluator) {
+  globalContractRegistry.registerEvaluator(contractId, clauseId, evaluator);
+}
+function registerReceiptSchema(entry) {
+  globalSchemaRegistry.registerSchema(entry);
+}
+function wrapSolverInContract(solver, contractId, schemaId, registry = globalContractRegistry, schemaReg = globalSchemaRegistry) {
+  return (config) => {
+    const contract = contractId ? registry.getContract(contractId) : void 0;
+    const clauseViolations = [];
+    if (contract) {
+      for (const clause of contract.preconditions) {
+        const evaluator = registry.getEvaluator(contract.id, clause.id);
+        if (!evaluator) continue;
+        const ctx = {
+          config,
+          result: void 0,
+          pluginId: contract.pluginId
+        };
+        const holds = evaluator(ctx);
+        if (!holds) {
+          clauseViolations.push({
+            clauseId: clause.id,
+            kind: "precondition",
+            severity: clause.severity ?? "error",
+            message: `Precondition "${clause.id}" violated: ${clause.description}`,
+            pluginId: contract.pluginId
+          });
+          if ((clause.severity ?? "error") === "error") {
+            return {
+              result: void 0,
+              contractVerified: false,
+              schemaValid: null,
+              schemaId: schemaId ?? null,
+              clauseViolations,
+              schemaViolations: [],
+              contractId: contractId ?? null,
+              pluginId: contract.pluginId
+            };
+          }
+        }
+      }
+    }
+    const result = solver(config);
+    if (contract) {
+      for (const clause of contract.postconditions) {
+        const evaluator = registry.getEvaluator(contract.id, clause.id);
+        if (!evaluator) continue;
+        const ctx = {
+          config,
+          result,
+          pluginId: contract.pluginId
+        };
+        const holds = evaluator(ctx);
+        if (!holds) {
+          clauseViolations.push({
+            clauseId: clause.id,
+            kind: "postcondition",
+            severity: clause.severity ?? "error",
+            message: `Postcondition "${clause.id}" violated: ${clause.description}`,
+            pluginId: contract.pluginId
+          });
+        }
+      }
+    }
+    const hasErrorViolation = clauseViolations.some((v) => v.severity === "error");
+    const contractVerified = !hasErrorViolation;
+    let schemaValid = null;
+    let schemaViolations = [];
+    if (schemaId) {
+      const schemaResult = schemaReg.validate(schemaId, result);
+      if (schemaResult !== null) {
+        schemaValid = schemaResult.valid;
+        schemaViolations = schemaResult.violations;
+      }
+    }
+    return {
+      result,
+      contractVerified,
+      schemaValid,
+      schemaId: schemaId ?? null,
+      clauseViolations,
+      schemaViolations,
+      contractId: contractId ?? null,
+      pluginId: contract?.pluginId ?? null
+    };
+  };
+}
+
+export { PluginSolverContractRegistry, SolverReceiptSchemaRegistry, globalContractRegistry, globalSchemaRegistry, registerContractClauseEvaluator, registerPluginContract, registerReceiptSchema, wrapSolverInContract };
+//# sourceMappingURL=chunk-NJSYWX7H.js.map
+//# sourceMappingURL=chunk-NJSYWX7H.js.map