@holoscript/core 8.0.8 → 8.0.10

package/dist/chunk-VVAAZITA.cjs

@@ -0,0 +1,287 @@
+'use strict';
+
+var chunk356N4NPM_cjs = require('./chunk-356N4NPM.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
+var crypto = require('crypto');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/DaimonSeedCompiler.ts
+var DaimonSeedCompiler_exports = {};
+chunkZHPMP447_cjs.__export(DaimonSeedCompiler_exports, {
+  DaimonSeedCompiler: () => exports.DaimonSeedCompiler,
+  computeExportFidelity: () => computeExportFidelity,
+  createDaimonSeedCompiler: () => createDaimonSeedCompiler,
+  default: () => exports.DaimonSeedCompiler_default,
+  runHysteresisExp2: () => runHysteresisExp2
+});
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function sha256Hex(value) {
+  return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function clamp01(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(1, value));
+}
+function assertEqualLength(a, b, label) {
+  if (a.length === 0 || b.length === 0) {
+    throw new Error(`${label} requires non-empty vectors`);
+  }
+  if (a.length !== b.length) {
+    throw new Error(`${label} requires equal-length vectors (${a.length} !== ${b.length})`);
+  }
+}
+function rootMeanSquareDivergence(a, b) {
+  assertEqualLength(a, b, "divergence");
+  const sum = a.reduce((acc, value, index) => {
+    const delta = value - b[index];
+    return acc + delta * delta;
+  }, 0);
+  return Math.sqrt(sum / a.length);
+}
+function isPlateaued(series, tolerance) {
+  if (series.length < 3) return false;
+  const last = series[series.length - 1];
+  const prev = series[series.length - 2];
+  const prior = series[series.length - 3];
+  const denom = Math.max(1, Math.abs(last));
+  return Math.abs(last - prev) / denom <= tolerance && Math.abs(prev - prior) / denom <= tolerance;
+}
+function normalizeTraitName(trait) {
+  return typeof trait === "string" ? trait : trait.name;
+}
+function primitiveValue(value) {
+  if (value == null) return value;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => primitiveValue(item));
+  }
+  return stableStringify(value);
+}
+function normalizeObject(obj) {
+  return {
+    name: obj.name,
+    traits: (obj.traits ?? []).map(normalizeTraitName).sort(),
+    properties: (obj.properties ?? []).map((property) => ({ key: property.key, value: primitiveValue(property.value) })).sort((a, b) => a.key.localeCompare(b.key)),
+    children: (obj.children ?? []).map(normalizeObject).sort((a, b) => String(a["name"]).localeCompare(String(b["name"])))
+  };
+}
+function collectObjects(composition) {
+  const objects = [];
+  const visit = (obj) => {
+    objects.push(obj);
+    for (const child of obj.children ?? []) visit(child);
+  };
+  for (const obj of composition.objects ?? []) visit(obj);
+  for (const group of composition.spatialGroups ?? []) {
+    for (const obj of group.objects ?? []) visit(obj);
+  }
+  return objects;
+}
+function collectTraitVocabulary(objects) {
+  const names = /* @__PURE__ */ new Set();
+  for (const obj of objects) {
+    for (const trait of obj.traits ?? []) {
+      names.add(normalizeTraitName(trait));
+    }
+  }
+  return [...names].sort();
+}
+function buildDomainSpec(composition) {
+  return {
+    compositionName: composition.name,
+    metadata: composition.metadata ?? {},
+    objects: (composition.objects ?? []).map(normalizeObject).sort((a, b) => String(a["name"]).localeCompare(String(b["name"]))),
+    spatialGroups: (composition.spatialGroups ?? []).map((group) => ({
+      name: group.name,
+      objects: (group.objects ?? []).map(normalizeObject).sort((a, b) => String(a["name"]).localeCompare(String(b["name"])))
+    })).sort((a, b) => a.name.localeCompare(b.name))
+  };
+}
+function computeExportFidelity(input) {
+  if (!(input.noiseFloor > 0)) {
+    throw new Error(`export fidelity requires noiseFloor > 0 (got ${input.noiseFloor})`);
+  }
+  const divergence = rootMeanSquareDivergence(input.runtimeVector, input.downloadedVector);
+  const exportFidelity = clamp01(1 - divergence / input.noiseFloor);
+  return {
+    divergence,
+    noiseFloor: input.noiseFloor,
+    exportFidelity,
+    forbiddenTheater: exportFidelity <= 0
+  };
+}
+function runHysteresisExp2(input) {
+  const threshold = input.coefficientThreshold ?? 1;
+  const plateauTolerance = input.plateauTolerance ?? 0.05;
+  const sameSeedNoiseFloor = rootMeanSquareDivergence(input.ordered, input.rerun);
+  const sameSetDivergence = rootMeanSquareDivergence(input.ordered, input.shuffled);
+  const denominator = Math.max(sameSeedNoiseFloor, Number.EPSILON);
+  const hysteresisCoefficient = sameSetDivergence / denominator;
+  const series = input.coefficientSeries ?? [hysteresisCoefficient, hysteresisCoefficient, hysteresisCoefficient];
+  const plateaued = isPlateaued(series, plateauTolerance);
+  const pathDependenceReal = hysteresisCoefficient > threshold && plateaued;
+  const diagnostic = pathDependenceReal ? "path-dependent" : !plateaued ? "not-plateaued" : "noise-floor";
+  return {
+    sameSeedNoiseFloor,
+    sameSetDivergence,
+    hysteresisCoefficient,
+    plateaued,
+    pathDependenceReal,
+    diagnostic
+  };
+}
+function createDaimonSeedCompiler(options) {
+  return new exports.DaimonSeedCompiler(options);
+}
+var SCHEMA_VERSION, DEFAULT_THRESHOLD_FACTS, DEFAULT_THRESHOLD_FN; exports.DaimonSeedCompiler = void 0; exports.DaimonSeedCompiler_default = void 0;
+var init_DaimonSeedCompiler = chunkZHPMP447_cjs.__esm({
+  "src/compiler/DaimonSeedCompiler.ts"() {
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    chunk356N4NPM_cjs.init_jsonLogic();
+    SCHEMA_VERSION = "holoscript.daimon-seed.v0.1.0";
+    DEFAULT_THRESHOLD_FACTS = {
+      emergenceCredit: 0.01,
+      custodyScore: 1,
+      measuredValueIndependence: 0.5
+    };
+    DEFAULT_THRESHOLD_FN = {
+      and: [
+        { ">=": [{ var: "emergenceCredit" }, 0.01] },
+        { ">=": [{ var: "custodyScore" }, 1] },
+        { ">=": [{ var: "measuredValueIndependence" }, 0.5] }
+      ]
+    };
+    exports.DaimonSeedCompiler = class extends chunkZK7KX5CD_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "DaimonSeedCompiler";
+        this.options = options;
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.DAIMON_SEED;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        const seed = this.compileSeed(composition);
+        return JSON.stringify(seed, null, 2);
+      }
+      compileToFiles(composition, agentToken = "") {
+        return { [this.defaultOutputFileName()]: this.compile(composition, agentToken) };
+      }
+      defaultOutputFileName() {
+        return "daimon-seed.json";
+      }
+      compileSeed(composition) {
+        const objects = collectObjects(composition);
+        const traitVocabulary = collectTraitVocabulary(objects);
+        const domainSpecHash = this.options.domainSpecHash ?? `sha256:${sha256Hex(buildDomainSpec(composition))}`;
+        const seedId = this.options.seedId ?? `daimon:${domainSpecHash.slice(-16)}`;
+        const thresholdFn = this.options.thresholdFn ?? DEFAULT_THRESHOLD_FN;
+        const thresholdFacts = this.options.thresholdFacts ?? DEFAULT_THRESHOLD_FACTS;
+        const thresholdPreview = {
+          facts: thresholdFacts,
+          result: chunk356N4NPM_cjs.evaluateJsonLogic(thresholdFn, thresholdFacts),
+          passed: chunk356N4NPM_cjs.matchesRule(thresholdFn, thresholdFacts)
+        };
+        const initialWeights = this.buildInitialWeights(traitVocabulary);
+        const seedWithoutDigest = {
+          schemaVersion: SCHEMA_VERSION,
+          kind: "DaimonSeed",
+          seedId,
+          domainSpecHash,
+          fieldPriors: this.buildFieldPriors(traitVocabulary.length),
+          thresholdFn,
+          thresholdRuntime: {
+            id: "ContentPolicyGate.jsonLogic",
+            source: "packages/core/src/policy/jsonLogic.ts",
+            operators: "shared-json-logic-subset"
+          },
+          thresholdPreview,
+          compositionPriors: {
+            traitVocabulary,
+            initialWeights
+          },
+          provenanceChainRef: this.options.provenanceChainRef ?? "provenance-chain:required",
+          emergenceContractRef: this.options.emergenceContractRef ?? "emergence-contract:required",
+          reproducibility: {
+            withinNoiseFloor: true,
+            ...this.options.noiseFloorRef ? { noiseFloorRef: this.options.noiseFloorRef } : {}
+          },
+          fidelityContract: {
+            metric: "exportFidelity",
+            formula: "1 - div(runtime,download)/noise_floor",
+            divergence: "rootMeanSquare",
+            lowFidelityVerdict: "forbidden_theater",
+            receiptRequired: true
+          },
+          hysteresisExp2: {
+            coefficient: "div(A,B)/div(A,A_prime)",
+            orderedArm: "A: original observation order",
+            shuffledArm: "B: same observation set, shuffled order",
+            rerunArm: "A_prime: same seed, same order rerun",
+            diagnosticRule: "path-dependence real iff coefficient > 1 and plateaus above noise floor",
+            diffContentArm: "upper-bound scale only, non-diagnostic"
+          },
+          custody: {
+            ownedObject: "lossless_recipe",
+            weightsOwnership: "not_owned",
+            runtimeOnly: ["realizedComposition", "observationPath", "soul"],
+            note: "compile the seed, receipt the emergence, never serialize the soul"
+          },
+          source: {
+            compositionName: composition.name,
+            objectCount: objects.length,
+            traitCount: traitVocabulary.length
+          }
+        };
+        const deterministicDigest = `sha256:${sha256Hex(seedWithoutDigest)}`;
+        return {
+          ...seedWithoutDigest,
+          reproducibility: {
+            ...seedWithoutDigest.reproducibility,
+            deterministicDigest
+          }
+        };
+      }
+      buildFieldPriors(traitCount) {
+        const priors = this.options.fieldPriors ?? {};
+        return {
+          tensorSchema: priors.tensorSchema ?? "trait-prior-vector/v1",
+          shape: priors.shape ?? [Math.max(traitCount, 1)],
+          dtype: priors.dtype ?? "float32",
+          weightsRef: priors.weightsRef ?? "weights:not-serialized"
+        };
+      }
+      buildInitialWeights(traitVocabulary) {
+        const out = {};
+        for (const trait of traitVocabulary) {
+          const configured = this.options.initialWeights?.[trait];
+          out[trait] = typeof configured === "number" && Number.isFinite(configured) ? configured : 1;
+        }
+        return out;
+      }
+    };
+    exports.DaimonSeedCompiler_default = exports.DaimonSeedCompiler;
+  }
+});
+
+exports.DaimonSeedCompiler_exports = DaimonSeedCompiler_exports;
+exports.computeExportFidelity = computeExportFidelity;
+exports.createDaimonSeedCompiler = createDaimonSeedCompiler;
+exports.init_DaimonSeedCompiler = init_DaimonSeedCompiler;
+exports.runHysteresisExp2 = runHysteresisExp2;
+//# sourceMappingURL=chunk-VVAAZITA.cjs.map
+//# sourceMappingURL=chunk-VVAAZITA.cjs.map