@holoscript/core 6.0.4 → 6.1.2

package/dist/paper-0c-spike/index.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var chunkLM2VU56C_cjs = require('../chunk-LM2VU56C.cjs');
+require('../chunk-HCCQLAA4.cjs');
+
+// src/paper-0c-spike/subgrid-attestation.ts
+var DEFAULT_HASH_MODE = "fnv1a";
+var MissingSubgridParamsError = class extends Error {
+  constructor() {
+    super(
+      "Subgrid parameter vector is required \xE2\u20AC\u201D empty or missing vectors are refused to prevent silent empty-hash attestation. Pass explicit keys with their run-time values."
+    );
+    this.name = "MissingSubgridParamsError";
+  }
+};
+var InvalidSubgridParamValueError = class extends Error {
+  constructor(key, value) {
+    super(
+      `Subgrid parameter '${key}' has invalid value ${String(value)} (type ${typeof value}). Allowed value types: finite number, boolean, string.`
+    );
+    this.name = "InvalidSubgridParamValueError";
+  }
+};
+function canonicalizeSubgridParams(params) {
+  const keys = Object.keys(params);
+  if (keys.length === 0) {
+    throw new MissingSubgridParamsError();
+  }
+  const sorted = keys.slice().sort();
+  const parts = [];
+  for (const key of sorted) {
+    const v = params[key];
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        throw new InvalidSubgridParamValueError(key, v);
+      }
+      parts.push(`${key}=${v.toString()}`);
+    } else if (typeof v === "boolean") {
+      parts.push(`${key}=${v ? "true" : "false"}`);
+    } else if (typeof v === "string") {
+      parts.push(`${key}=\`${v}\``);
+    } else {
+      throw new InvalidSubgridParamValueError(key, v);
+    }
+  }
+  return parts.join("|");
+}
+async function sha256Hex(input) {
+  const subtle = typeof globalThis.crypto !== "undefined" && "subtle" in globalThis.crypto ? globalThis.crypto.subtle : void 0;
+  if (!subtle) {
+    throw new Error(
+      "SubtleCrypto unavailable: SHA-256 mode requires Web Crypto (Node 20+, browsers, Deno)."
+    );
+  }
+  const bytes = new TextEncoder().encode(input);
+  const digest = await subtle.digest("SHA-256", bytes);
+  const view = new Uint8Array(digest);
+  const hex = [];
+  for (const b of view) hex.push(b.toString(16).padStart(2, "0"));
+  return hex.join("");
+}
+function hashSubgridParams(params, mode = DEFAULT_HASH_MODE) {
+  const canonical = canonicalizeSubgridParams(params);
+  if (mode === "fnv1a") return chunkLM2VU56C_cjs.fnv1a32Hex(canonical);
+  if (mode === "sha256") return sha256Hex(canonical);
+  throw new Error(`Unknown hash mode: ${String(mode)}`);
+}
+function attestSubgridParams(params, mode = DEFAULT_HASH_MODE) {
+  const canonicalForm = canonicalizeSubgridParams(params);
+  if (mode === "fnv1a") {
+    return Object.freeze({
+      hash: chunkLM2VU56C_cjs.fnv1a32Hex(canonicalForm),
+      hashMode: "fnv1a",
+      canonicalForm
+    });
+  }
+  if (mode === "sha256") {
+    return sha256Hex(canonicalForm).then(
+      (hash) => Object.freeze({ hash, hashMode: "sha256", canonicalForm })
+    );
+  }
+  throw new Error(`Unknown hash mode: ${String(mode)}`);
+}
+var FNV1A_HEX_SHAPE = /^[0-9a-f]{16}$/;
+var SHA256_HEX_SHAPE = /^[0-9a-f]{64}$/;
+function describeExpectedShape(mode) {
+  return mode === "fnv1a" ? "fnv1a hash (16 hex chars)" : "sha256 hash (64 hex chars)";
+}
+function verifySubgridAttestation(attestation, params) {
+  const canonical = canonicalizeSubgridParams(params);
+  if (canonical !== attestation.canonicalForm) {
+    return {
+      valid: false,
+      reason: "canonical-form-mismatch",
+      expected: attestation.canonicalForm,
+      actual: canonical
+    };
+  }
+  const expectedShape = attestation.hashMode === "fnv1a" ? FNV1A_HEX_SHAPE : SHA256_HEX_SHAPE;
+  if (!expectedShape.test(attestation.hash)) {
+    return {
+      valid: false,
+      reason: "hashMode-mismatch",
+      expected: describeExpectedShape(attestation.hashMode),
+      actual: `${attestation.hash.length} hex chars`
+    };
+  }
+  if (attestation.hashMode === "fnv1a") {
+    const computed = chunkLM2VU56C_cjs.fnv1a32Hex(canonical);
+    return computed === attestation.hash ? { valid: true } : { valid: false, reason: "hash-mismatch", expected: attestation.hash, actual: computed };
+  }
+  throw new Error(
+    "verifySubgridAttestation: sha256 mode requires verifySubgridAttestationAsync (async crypto)."
+  );
+}
+async function verifySubgridAttestationAsync(attestation, params) {
+  if (attestation.hashMode === "fnv1a") {
+    return verifySubgridAttestation(attestation, params);
+  }
+  const canonical = canonicalizeSubgridParams(params);
+  if (canonical !== attestation.canonicalForm) {
+    return {
+      valid: false,
+      reason: "canonical-form-mismatch",
+      expected: attestation.canonicalForm,
+      actual: canonical
+    };
+  }
+  if (!SHA256_HEX_SHAPE.test(attestation.hash)) {
+    return {
+      valid: false,
+      reason: "hashMode-mismatch",
+      expected: describeExpectedShape("sha256"),
+      actual: `${attestation.hash.length} hex chars`
+    };
+  }
+  const computed = await sha256Hex(canonical);
+  return computed === attestation.hash ? { valid: true } : { valid: false, reason: "hash-mismatch", expected: attestation.hash, actual: computed };
+}
+
+exports.DEFAULT_HASH_MODE = DEFAULT_HASH_MODE;
+exports.InvalidSubgridParamValueError = InvalidSubgridParamValueError;
+exports.MissingSubgridParamsError = MissingSubgridParamsError;
+exports.attestSubgridParams = attestSubgridParams;
+exports.canonicalizeSubgridParams = canonicalizeSubgridParams;
+exports.hashSubgridParams = hashSubgridParams;
+exports.verifySubgridAttestation = verifySubgridAttestation;
+exports.verifySubgridAttestationAsync = verifySubgridAttestationAsync;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/paper-0c-spike/index.d.ts

@@ -0,0 +1,29 @@
+/** @holoscript/core/paper-0c-spike — CAEL paper-0c primitives (subgrid attestation) */
+export type HashMode = 'fnv1a' | 'sha256';
+export declare const DEFAULT_HASH_MODE: HashMode;
+export type SubgridParamValue = number | boolean | string;
+export type SubgridParams = Record<string, SubgridParamValue>;
+export interface SubgridAttestation {
+  readonly hash: string;
+  readonly hashMode: HashMode;
+  readonly canonicalForm: string;
+}
+export type VerifyResult =
+  | { readonly valid: true }
+  | {
+      readonly valid: false;
+      readonly reason: 'hashMode-mismatch' | 'hash-mismatch' | 'canonical-form-mismatch';
+      readonly expected: string;
+      readonly actual: string;
+    };
+export declare class MissingSubgridParamsError extends Error { constructor(); }
+export declare class InvalidSubgridParamValueError extends Error { constructor(key: string, value: unknown); }
+export declare function canonicalizeSubgridParams(params: SubgridParams): string;
+export declare function hashSubgridParams(params: SubgridParams, mode: 'fnv1a'): string;
+export declare function hashSubgridParams(params: SubgridParams, mode: 'sha256'): Promise<string>;
+export declare function hashSubgridParams(params: SubgridParams, mode?: HashMode): string | Promise<string>;
+export declare function attestSubgridParams(params: SubgridParams, mode: 'fnv1a'): SubgridAttestation;
+export declare function attestSubgridParams(params: SubgridParams, mode: 'sha256'): Promise<SubgridAttestation>;
+export declare function attestSubgridParams(params: SubgridParams, mode?: HashMode): SubgridAttestation | Promise<SubgridAttestation>;
+export declare function verifySubgridAttestation(attestation: SubgridAttestation, params: SubgridParams): VerifyResult;
+export declare function verifySubgridAttestationAsync(attestation: SubgridAttestation, params: SubgridParams): Promise<VerifyResult>;

package/dist/paper-0c-spike/index.js

@@ -0,0 +1,141 @@
+import { fnv1a32Hex } from '../chunk-WNNE3PO3.js';
+import '../chunk-OL46QLBJ.js';
+
+// src/paper-0c-spike/subgrid-attestation.ts
+var DEFAULT_HASH_MODE = "fnv1a";
+var MissingSubgridParamsError = class extends Error {
+  constructor() {
+    super(
+      "Subgrid parameter vector is required \xE2\u20AC\u201D empty or missing vectors are refused to prevent silent empty-hash attestation. Pass explicit keys with their run-time values."
+    );
+    this.name = "MissingSubgridParamsError";
+  }
+};
+var InvalidSubgridParamValueError = class extends Error {
+  constructor(key, value) {
+    super(
+      `Subgrid parameter '${key}' has invalid value ${String(value)} (type ${typeof value}). Allowed value types: finite number, boolean, string.`
+    );
+    this.name = "InvalidSubgridParamValueError";
+  }
+};
+function canonicalizeSubgridParams(params) {
+  const keys = Object.keys(params);
+  if (keys.length === 0) {
+    throw new MissingSubgridParamsError();
+  }
+  const sorted = keys.slice().sort();
+  const parts = [];
+  for (const key of sorted) {
+    const v = params[key];
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        throw new InvalidSubgridParamValueError(key, v);
+      }
+      parts.push(`${key}=${v.toString()}`);
+    } else if (typeof v === "boolean") {
+      parts.push(`${key}=${v ? "true" : "false"}`);
+    } else if (typeof v === "string") {
+      parts.push(`${key}=\`${v}\``);
+    } else {
+      throw new InvalidSubgridParamValueError(key, v);
+    }
+  }
+  return parts.join("|");
+}
+async function sha256Hex(input) {
+  const subtle = typeof globalThis.crypto !== "undefined" && "subtle" in globalThis.crypto ? globalThis.crypto.subtle : void 0;
+  if (!subtle) {
+    throw new Error(
+      "SubtleCrypto unavailable: SHA-256 mode requires Web Crypto (Node 20+, browsers, Deno)."
+    );
+  }
+  const bytes = new TextEncoder().encode(input);
+  const digest = await subtle.digest("SHA-256", bytes);
+  const view = new Uint8Array(digest);
+  const hex = [];
+  for (const b of view) hex.push(b.toString(16).padStart(2, "0"));
+  return hex.join("");
+}
+function hashSubgridParams(params, mode = DEFAULT_HASH_MODE) {
+  const canonical = canonicalizeSubgridParams(params);
+  if (mode === "fnv1a") return fnv1a32Hex(canonical);
+  if (mode === "sha256") return sha256Hex(canonical);
+  throw new Error(`Unknown hash mode: ${String(mode)}`);
+}
+function attestSubgridParams(params, mode = DEFAULT_HASH_MODE) {
+  const canonicalForm = canonicalizeSubgridParams(params);
+  if (mode === "fnv1a") {
+    return Object.freeze({
+      hash: fnv1a32Hex(canonicalForm),
+      hashMode: "fnv1a",
+      canonicalForm
+    });
+  }
+  if (mode === "sha256") {
+    return sha256Hex(canonicalForm).then(
+      (hash) => Object.freeze({ hash, hashMode: "sha256", canonicalForm })
+    );
+  }
+  throw new Error(`Unknown hash mode: ${String(mode)}`);
+}
+var FNV1A_HEX_SHAPE = /^[0-9a-f]{16}$/;
+var SHA256_HEX_SHAPE = /^[0-9a-f]{64}$/;
+function describeExpectedShape(mode) {
+  return mode === "fnv1a" ? "fnv1a hash (16 hex chars)" : "sha256 hash (64 hex chars)";
+}
+function verifySubgridAttestation(attestation, params) {
+  const canonical = canonicalizeSubgridParams(params);
+  if (canonical !== attestation.canonicalForm) {
+    return {
+      valid: false,
+      reason: "canonical-form-mismatch",
+      expected: attestation.canonicalForm,
+      actual: canonical
+    };
+  }
+  const expectedShape = attestation.hashMode === "fnv1a" ? FNV1A_HEX_SHAPE : SHA256_HEX_SHAPE;
+  if (!expectedShape.test(attestation.hash)) {
+    return {
+      valid: false,
+      reason: "hashMode-mismatch",
+      expected: describeExpectedShape(attestation.hashMode),
+      actual: `${attestation.hash.length} hex chars`
+    };
+  }
+  if (attestation.hashMode === "fnv1a") {
+    const computed = fnv1a32Hex(canonical);
+    return computed === attestation.hash ? { valid: true } : { valid: false, reason: "hash-mismatch", expected: attestation.hash, actual: computed };
+  }
+  throw new Error(
+    "verifySubgridAttestation: sha256 mode requires verifySubgridAttestationAsync (async crypto)."
+  );
+}
+async function verifySubgridAttestationAsync(attestation, params) {
+  if (attestation.hashMode === "fnv1a") {
+    return verifySubgridAttestation(attestation, params);
+  }
+  const canonical = canonicalizeSubgridParams(params);
+  if (canonical !== attestation.canonicalForm) {
+    return {
+      valid: false,
+      reason: "canonical-form-mismatch",
+      expected: attestation.canonicalForm,
+      actual: canonical
+    };
+  }
+  if (!SHA256_HEX_SHAPE.test(attestation.hash)) {
+    return {
+      valid: false,
+      reason: "hashMode-mismatch",
+      expected: describeExpectedShape("sha256"),
+      actual: `${attestation.hash.length} hex chars`
+    };
+  }
+  const computed = await sha256Hex(canonical);
+  return computed === attestation.hash ? { valid: true } : { valid: false, reason: "hash-mismatch", expected: attestation.hash, actual: computed };
+}
+
+export { DEFAULT_HASH_MODE, InvalidSubgridParamValueError, MissingSubgridParamsError, attestSubgridParams, canonicalizeSubgridParams, hashSubgridParams, verifySubgridAttestation, verifySubgridAttestationAsync };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/parser.cjs

@@ -1,27 +1,61 @@
 'use strict';
 
-var chunkLZ266PCM_cjs = require('./chunk-LZ266PCM.cjs');
-require('./chunk-GVUR45UF.cjs');
-require('./chunk-XG23EUQX.cjs');
-require('./chunk-KCQ5NDYC.cjs');
-require('./chunk-PMGODDJA.cjs');
-require('./chunk-MD6KDHVE.cjs');
-require('./chunk-CAUCGUEA.cjs');
-require('./chunk-3SAK5KFL.cjs');
+var chunk2HLIGOKU_cjs = require('./chunk-2HLIGOKU.cjs');
+require('./chunk-KKFZ3B6J.cjs');
+var chunkT5J7ZKP3_cjs = require('./chunk-T5J7ZKP3.cjs');
+require('./chunk-NG77ATEW.cjs');
+require('./chunk-WRLUBRKS.cjs');
+require('./chunk-X3GJPRVK.cjs');
+require('./chunk-DTGBOSEM.cjs');
+require('./chunk-YKGPCZEE.cjs');
+require('./chunk-6EX3I5P4.cjs');
+require('./chunk-HCCQLAA4.cjs');
 
 
 
+Object.defineProperty(exports, "HoloCompositionParser", {
+  enumerable: true,
+  get: function () { return chunk2HLIGOKU_cjs.HoloCompositionParser; }
+});
+Object.defineProperty(exports, "parseHolo", {
+  enumerable: true,
+  get: function () { return chunk2HLIGOKU_cjs.parseHolo; }
+});
+Object.defineProperty(exports, "parseHoloPartial", {
+  enumerable: true,
+  get: function () { return chunk2HLIGOKU_cjs.parseHoloPartial; }
+});
+Object.defineProperty(exports, "parseHoloStrict", {
+  enumerable: true,
+  get: function () { return chunk2HLIGOKU_cjs.parseHoloStrict; }
+});
+Object.defineProperty(exports, "ChunkBasedIncrementalParser", {
+  enumerable: true,
+  get: function () { return chunkT5J7ZKP3_cjs.ChunkBasedIncrementalParser; }
+});
 Object.defineProperty(exports, "HoloScriptPlusParser", {
   enumerable: true,
-  get: function () { return chunkLZ266PCM_cjs.HoloScriptPlusParser; }
+  get: function () { return chunkT5J7ZKP3_cjs.HoloScriptPlusParser; }
+});
+Object.defineProperty(exports, "ParseCache", {
+  enumerable: true,
+  get: function () { return chunkT5J7ZKP3_cjs.ParseCache; }
 });
 Object.defineProperty(exports, "createParser", {
   enumerable: true,
-  get: function () { return chunkLZ266PCM_cjs.createParser; }
+  get: function () { return chunkT5J7ZKP3_cjs.createParser; }
+});
+Object.defineProperty(exports, "globalParseCache", {
+  enumerable: true,
+  get: function () { return chunkT5J7ZKP3_cjs.globalParseCache; }
 });
 Object.defineProperty(exports, "parse", {
   enumerable: true,
-  get: function () { return chunkLZ266PCM_cjs.parse; }
+  get: function () { return chunkT5J7ZKP3_cjs.parse; }
+});
+Object.defineProperty(exports, "parseIncrementalChunks", {
+  enumerable: true,
+  get: function () { return chunkT5J7ZKP3_cjs.parseIncrementalChunks; }
 });
 //# sourceMappingURL=parser.cjs.map
 //# sourceMappingURL=parser.cjs.map

package/dist/parser.d.ts

@@ -2,3 +2,14 @@ export class HoloScriptPlusParser {
   parse(source: string): any;
 }
 export function parse(source: string): any;
+export function createParser(options?: any): HoloScriptPlusParser;
+export class HoloCompositionParser {
+  constructor(options?: any);
+  parse(source: string): any;
+}
+export function parseHolo(source: string, options?: any): any;
+export function parseHoloStrict(source: string, options?: any): any;
+export function parseHoloPartial(source: string, options?: any): any;
+export type HoloParseResult = any;
+export type HoloParseError = any;
+export type HoloParserOptions = any;

package/dist/parser.js

@@ -1,10 +1,12 @@
-export { HoloScriptPlusParser, createParser, parse } from './chunk-V3NN3HPP.js';
-import './chunk-MPXBVFHQ.js';
-import './chunk-NDQNIJEH.js';
-import './chunk-IFNQFCTM.js';
-import './chunk-HPS76H7Q.js';
-import './chunk-WB4Z63GG.js';
-import './chunk-XUTX5CBW.js';
-import './chunk-2CWOLHTE.js';
+export { HoloCompositionParser, parseHolo, parseHoloPartial, parseHoloStrict } from './chunk-TK74TR4H.js';
+import './chunk-J32ZJZJH.js';
+export { ChunkBasedIncrementalParser, HoloScriptPlusParser, ParseCache, createParser, globalParseCache, parse, parseIncrementalChunks } from './chunk-YIMN575O.js';
+import './chunk-4N4SXXWF.js';
+import './chunk-2BSMSUCE.js';
+import './chunk-WRNEH5MO.js';
+import './chunk-WKX5AMOY.js';
+import './chunk-SIEXCILW.js';
+import './chunk-CBJY23VL.js';
+import './chunk-OL46QLBJ.js';
 //# sourceMappingURL=parser.js.map
 //# sourceMappingURL=parser.js.map