@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-VECQYRXL.js

@@ -0,0 +1,474 @@
+// src/traits/BotanicalLotusTrait.ts
+var DEFAULT_BOTANICAL_LOTUS_CONFIG = {
+  schema: "holoscript.trait.botanical_lotus.v0",
+  status: "visual_seed",
+  source: {
+    kind: "conversation_reference_images",
+    count: 3,
+    content_hash_status: "pending_media_ingest",
+    wallet_signature_status: "pending_cael_anchor",
+    note: "Derived from three pink lotus reference images provided in-thread; raw media ingest is pending."
+  },
+  reference_anchors: [
+    {
+      id: "lotus-reference-2026-05-06-01",
+      label: "open pink lotus close-up",
+      uri: "conversation://2026-05-06/lotus-reference-01",
+      role: "material",
+      status: "pending_media_ingest"
+    },
+    {
+      id: "lotus-reference-2026-05-06-02",
+      label: "upright pink lotus silhouette",
+      uri: "conversation://2026-05-06/lotus-reference-02",
+      role: "silhouette",
+      status: "pending_media_ingest"
+    },
+    {
+      id: "lotus-reference-2026-05-06-03",
+      label: "pink lotus with leaves and water context",
+      uri: "conversation://2026-05-06/lotus-reference-03",
+      role: "leaf_context",
+      status: "pending_media_ingest"
+    }
+  ],
+  material: {
+    subsurface_scattering: 0.74,
+    subsurface_radius_rgb: [0.9, 0.32, 0.72],
+    petal_translucency_base: 0.68,
+    petal_translucency_edge: 0.36,
+    roughness: 0.72,
+    ior: 1.36,
+    vein_normal_intensity: 0.045,
+    edge_curl_intensity: 0.58,
+    gravity_sag_outer: 0.3
+  },
+  colors: {
+    petal_base: "#fff1f6",
+    petal_mid: "#f47ab7",
+    petal_inner: "#ff9ecf",
+    petal_rim: "#c42a86",
+    petal_shadow: "#84205f",
+    seed_pod: "#f4d74a",
+    seed_pod_rim: "#b7c66b",
+    stamen: "#f59e0b",
+    stamen_tip: "#fff4bd",
+    leaf: "#235f4f",
+    leaf_dark: "#102f28",
+    water: "#07140f"
+  },
+  geometry: {
+    petal_rings: [
+      { name: "inner", count: 8, cup: 0.86, gravity_sag: 0.02 },
+      { name: "mid", count: 13, cup: 0.5, gravity_sag: 0.12 },
+      { name: "outer", count: 21, cup: 0.24, gravity_sag: 0.3 }
+    ],
+    petal_shape: "broad_elliptic_pointed_tip_with_center_ridge",
+    stamen_filament_count: 58,
+    seed_pod_dot_pattern: "1_center_7_12_18_radial"
+  },
+  renderer: {
+    requires: ["sss_render", "instanced_filaments", "water_surface"],
+    lod: {
+      close: "full_filaments",
+      mid: "simplified_filaments",
+      far: "petal_billboard"
+    },
+    material_model: "thin_tissue_mesh_physical_material"
+  }
+};
+var SHA256_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+var HEX_COLOR_PATTERN = /^#[0-9a-fA-F]{6}$/;
+var RING_RENDER_DEFAULTS = {
+  inner: { radius: 0.32, length: 0.82, width: 0.34, pitch_degrees: 74 },
+  mid: { radius: 0.58, length: 1.15, width: 0.46, pitch_degrees: 42 },
+  outer: { radius: 0.92, length: 1.52, width: 0.58, pitch_degrees: 18 }
+};
+function cloneDefaultConfig() {
+  const d = DEFAULT_BOTANICAL_LOTUS_CONFIG;
+  return {
+    ...d,
+    source: { ...d.source },
+    reference_anchors: d.reference_anchors.map((a) => ({ ...a })),
+    material: {
+      ...d.material,
+      subsurface_radius_rgb: [...d.material.subsurface_radius_rgb]
+    },
+    colors: { ...d.colors },
+    geometry: {
+      ...d.geometry,
+      petal_rings: d.geometry.petal_rings.map((r) => ({ ...r }))
+    },
+    renderer: {
+      ...d.renderer,
+      requires: [...d.renderer.requires],
+      lod: { ...d.renderer.lod }
+    }
+  };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function addRangeError(errors, label, value, min, max) {
+  if (!isFiniteNumber(value) || value < min || value > max) {
+    errors.push(`${label} must be a finite number in [${min}, ${max}]`);
+  }
+}
+function validateHexColors(errors, colors) {
+  for (const [key, value] of Object.entries(colors)) {
+    if (!HEX_COLOR_PATTERN.test(value)) {
+      errors.push(`colors.${key} must be a 6-digit hex color`);
+    }
+  }
+}
+function validateReferenceAnchor(errors, anchor, index) {
+  const prefix = `reference_anchors[${index}]`;
+  if (!anchor.id || typeof anchor.id !== "string") {
+    errors.push(`${prefix}.id is required`);
+  }
+  if (!anchor.uri || typeof anchor.uri !== "string") {
+    errors.push(`${prefix}.uri is required`);
+  }
+  if (anchor.status !== "pending_media_ingest" && anchor.status !== "hashed" && anchor.status !== "wallet_signed") {
+    errors.push(`${prefix}.status must be pending_media_ingest, hashed, or wallet_signed`);
+  }
+  if (anchor.status !== "pending_media_ingest") {
+    if (!anchor.content_hash || !SHA256_HASH_PATTERN.test(anchor.content_hash)) {
+      errors.push(`${prefix}.content_hash must be sha256:<64 lowercase hex chars>`);
+    }
+  }
+  if (anchor.status === "wallet_signed" && !anchor.wallet_signature) {
+    errors.push(`${prefix}.wallet_signature is required when status is wallet_signed`);
+  }
+  if (anchor.width !== void 0 && (!Number.isInteger(anchor.width) || anchor.width <= 0)) {
+    errors.push(`${prefix}.width must be a positive integer when present`);
+  }
+  if (anchor.height !== void 0 && (!Number.isInteger(anchor.height) || anchor.height <= 0)) {
+    errors.push(`${prefix}.height must be a positive integer when present`);
+  }
+}
+function normalizeBotanicalLotusConfig(input = {}) {
+  const d = cloneDefaultConfig();
+  const inputGeometry = input.geometry ?? {};
+  const inputRenderer = input.renderer ?? {};
+  const petalRings = Array.isArray(inputGeometry.petal_rings) ? inputGeometry.petal_rings.map((r) => ({ ...r })) : d.geometry.petal_rings.map((r) => ({ ...r }));
+  return {
+    schema: input.schema ?? d.schema,
+    status: input.status ?? d.status,
+    source: {
+      ...d.source,
+      ...input.source ?? {}
+    },
+    reference_anchors: Array.isArray(input.reference_anchors) ? input.reference_anchors.map((a) => ({ ...a })) : d.reference_anchors,
+    material: {
+      ...d.material,
+      ...input.material ?? {},
+      subsurface_radius_rgb: [
+        ...input.material?.subsurface_radius_rgb ?? d.material.subsurface_radius_rgb
+      ]
+    },
+    colors: {
+      ...d.colors,
+      ...input.colors ?? {}
+    },
+    geometry: {
+      ...d.geometry,
+      ...inputGeometry,
+      petal_rings: petalRings
+    },
+    renderer: {
+      ...d.renderer,
+      ...inputRenderer,
+      requires: [...inputRenderer.requires ?? d.renderer.requires],
+      lod: {
+        ...d.renderer.lod,
+        ...inputRenderer.lod ?? {}
+      }
+    }
+  };
+}
+function validateBotanicalLotusConfig(input = {}) {
+  const config = normalizeBotanicalLotusConfig(input);
+  const errors = [];
+  const { material, geometry } = config;
+  if (config.schema !== "holoscript.trait.botanical_lotus.v0") {
+    errors.push("schema must be holoscript.trait.botanical_lotus.v0");
+  }
+  if (config.status !== "visual_seed" && config.status !== "content_hashed" && config.status !== "wallet_signed") {
+    errors.push("status must be visual_seed, content_hashed, or wallet_signed");
+  }
+  if (config.reference_anchors.length === 0) {
+    errors.push("reference_anchors must include at least one anchor");
+  }
+  config.reference_anchors.forEach(
+    (anchor, index) => validateReferenceAnchor(errors, anchor, index)
+  );
+  addRangeError(errors, "material.subsurface_scattering", material.subsurface_scattering, 0, 1);
+  if (material.subsurface_radius_rgb.length !== 3) {
+    errors.push("material.subsurface_radius_rgb must contain exactly three values");
+  }
+  material.subsurface_radius_rgb.forEach(
+    (value, index) => addRangeError(errors, `material.subsurface_radius_rgb[${index}]`, value, 0, 2)
+  );
+  addRangeError(
+    errors,
+    "material.petal_translucency_base",
+    material.petal_translucency_base,
+    0,
+    1
+  );
+  addRangeError(
+    errors,
+    "material.petal_translucency_edge",
+    material.petal_translucency_edge,
+    0,
+    1
+  );
+  addRangeError(errors, "material.roughness", material.roughness, 0, 1);
+  addRangeError(errors, "material.ior", material.ior, 1, 2.5);
+  addRangeError(
+    errors,
+    "material.vein_normal_intensity",
+    material.vein_normal_intensity,
+    0,
+    0.25
+  );
+  addRangeError(errors, "material.edge_curl_intensity", material.edge_curl_intensity, 0, 1);
+  addRangeError(errors, "material.gravity_sag_outer", material.gravity_sag_outer, 0, 1);
+  validateHexColors(errors, config.colors);
+  if (geometry.petal_rings.length === 0) {
+    errors.push("geometry.petal_rings must include at least one ring");
+  }
+  geometry.petal_rings.forEach((ring, index) => {
+    if (!ring.name) {
+      errors.push(`geometry.petal_rings[${index}].name is required`);
+    }
+    if (!Number.isInteger(ring.count) || ring.count <= 0) {
+      errors.push(`geometry.petal_rings[${index}].count must be a positive integer`);
+    }
+    addRangeError(errors, `geometry.petal_rings[${index}].cup`, ring.cup, 0, 1);
+    addRangeError(
+      errors,
+      `geometry.petal_rings[${index}].gravity_sag`,
+      ring.gravity_sag,
+      0,
+      1
+    );
+  });
+  if (!Number.isInteger(geometry.stamen_filament_count) || geometry.stamen_filament_count <= 0) {
+    errors.push("geometry.stamen_filament_count must be a positive integer");
+  }
+  if (config.renderer.requires.length === 0) {
+    errors.push("renderer.requires must include at least one render capability");
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    config
+  };
+}
+function assertBotanicalLotusConfig(input = {}) {
+  const result = validateBotanicalLotusConfig(input);
+  if (!result.ok) {
+    throw new Error(`Invalid botanical_lotus config: ${result.errors.join("; ")}`);
+  }
+  return result.config;
+}
+function deriveBotanicalLotusAnchorStatus(anchors) {
+  if (anchors.length > 0 && anchors.every((anchor) => anchor.status === "wallet_signed")) {
+    return "wallet_signed";
+  }
+  if (anchors.length > 0 && anchors.every((anchor) => anchor.status === "hashed" || anchor.status === "wallet_signed")) {
+    return "hashed";
+  }
+  return "pending_media_ingest";
+}
+function getBotanicalLotusPetalCount(input = {}) {
+  const config = normalizeBotanicalLotusConfig(input);
+  return config.geometry.petal_rings.reduce((sum, ring) => sum + ring.count, 0);
+}
+function createBotanicalLotusRenderProfile(input = {}, placement, lighting) {
+  const config = assertBotanicalLotusConfig(input);
+  const anchorStatus = deriveBotanicalLotusAnchorStatus(config.reference_anchors);
+  const petalRings = config.geometry.petal_rings.map((ring, index) => {
+    const base = RING_RENDER_DEFAULTS[ring.name] ?? {
+      radius: 0.42 + index * 0.24,
+      length: 0.82 + index * 0.2,
+      width: 0.34 + index * 0.08,
+      pitch_degrees: Math.max(12, 70 - index * 18)
+    };
+    return {
+      name: ring.name,
+      count: ring.count,
+      radius: base.radius,
+      length: base.length,
+      width: base.width,
+      cup: ring.cup,
+      gravity_sag: ring.gravity_sag,
+      pitch_degrees: base.pitch_degrees
+    };
+  });
+  return {
+    trait: "botanical_lotus",
+    anchor_status: anchorStatus,
+    wallet_signed: anchorStatus === "wallet_signed",
+    petal_count: petalRings.reduce((sum, ring) => sum + ring.count, 0),
+    petal_rings: petalRings,
+    pbr_uniforms: {
+      subsurface_scattering: config.material.subsurface_scattering,
+      subsurface_radius_rgb: config.material.subsurface_radius_rgb,
+      transmission: config.material.petal_translucency_base,
+      thickness: config.material.petal_translucency_edge,
+      roughness: config.material.roughness,
+      ior: config.material.ior,
+      vein_normal_intensity: config.material.vein_normal_intensity
+    },
+    colors: config.colors,
+    stamen_filament_count: config.geometry.stamen_filament_count,
+    seed_pod_dot_pattern: config.geometry.seed_pod_dot_pattern,
+    reference_anchor_ids: config.reference_anchors.map((anchor) => anchor.id),
+    renderer_requires: config.renderer.requires,
+    surface_anchor_id: placement?.surface_anchor_id,
+    lighting_reference: lighting?.reference_id
+  };
+}
+var botanicalLotusHandler = {
+  name: "botanical_lotus",
+  defaultConfig: DEFAULT_BOTANICAL_LOTUS_CONFIG,
+  validate: validateBotanicalLotusConfig,
+  toRenderProfile: createBotanicalLotusRenderProfile,
+  onAttach(node, config, context) {
+    const normalized = assertBotanicalLotusConfig(config);
+    const profile = createBotanicalLotusRenderProfile(normalized);
+    const state = { config: normalized, profile };
+    node.__botanicalLotusState = state;
+    const nodeId = String(node.id ?? "unknown");
+    context.setState?.({
+      [`botanical_lotus.${nodeId}.anchor_status`]: profile.anchor_status,
+      [`botanical_lotus.${nodeId}.petal_count`]: profile.petal_count
+    });
+    context.emit?.("botanical_lotus_attached", {
+      node,
+      anchorStatus: profile.anchor_status,
+      walletSigned: profile.wallet_signed,
+      petalCount: profile.petal_count,
+      referenceAnchorIds: profile.reference_anchor_ids,
+      rendererRequires: profile.renderer_requires
+    });
+  },
+  onDetach(node, _config, context) {
+    context.emit?.("botanical_lotus_detached", { node });
+    delete node.__botanicalLotusState;
+  },
+  onUpdate(_node, _config, _context, _delta) {
+  },
+  onEvent(node, _config, context, event) {
+    const state = node.__botanicalLotusState;
+    if (!state) return;
+    if (event.type === "botanical_lotus_query") {
+      context.emit?.("botanical_lotus_response", {
+        queryId: event.queryId,
+        node,
+        config: state.config,
+        profile: state.profile
+      });
+      return;
+    }
+    if (event.type === "botanical_lotus_reference_anchored") {
+      const anchorId = String(event.anchorId ?? "");
+      const contentHash = typeof event.contentHash === "string" ? event.contentHash : void 0;
+      const walletSignature = typeof event.walletSignature === "string" ? event.walletSignature : void 0;
+      if (!anchorId || !contentHash) return;
+      const updatedAnchors = state.config.reference_anchors.map((anchor) => {
+        if (anchor.id !== anchorId) return anchor;
+        return {
+          ...anchor,
+          content_hash: contentHash,
+          wallet_signature: walletSignature,
+          status: walletSignature ? "wallet_signed" : "hashed"
+        };
+      });
+      const updatedConfig = assertBotanicalLotusConfig({
+        ...state.config,
+        status: updatedAnchors.every((anchor) => anchor.status === "wallet_signed") ? "wallet_signed" : "content_hashed",
+        source: {
+          ...state.config.source,
+          content_hash_status: deriveBotanicalLotusAnchorStatus(updatedAnchors),
+          wallet_signature_status: updatedAnchors.every(
+            (anchor) => anchor.status === "wallet_signed"
+          ) ? "wallet_signed" : "pending_cael_anchor"
+        },
+        reference_anchors: updatedAnchors
+      });
+      state.config = updatedConfig;
+      state.profile = createBotanicalLotusRenderProfile(updatedConfig, state.placement, state.lighting);
+      context.emit?.("botanical_lotus_reference_updated", {
+        node,
+        anchorId,
+        anchorStatus: state.profile.anchor_status,
+        walletSigned: state.profile.wallet_signed,
+        referenceAnchorIds: state.profile.reference_anchor_ids
+      });
+      return;
+    }
+    if (event.type === "holomap:surface_anchor_placed") {
+      const payload = event.payload ?? {};
+      const surfaceAnchorId = typeof payload.surfaceAnchorId === "string" ? payload.surfaceAnchorId : void 0;
+      const surfaceNormal = Array.isArray(payload.surfaceNormal) ? payload.surfaceNormal : void 0;
+      const worldPosition = Array.isArray(payload.worldPosition) ? payload.worldPosition : void 0;
+      if (!surfaceAnchorId) return;
+      state.placement = {
+        surface_anchor_id: surfaceAnchorId,
+        surface_normal: surfaceNormal,
+        world_position: worldPosition
+      };
+      state.profile = createBotanicalLotusRenderProfile(state.config, state.placement, state.lighting);
+      context.emit?.("botanical_lotus_surface_bound", {
+        node,
+        surfaceAnchorId,
+        surfaceNormal,
+        worldPosition
+      });
+      return;
+    }
+    if (event.type === "holomap:lighting_update") {
+      const payload = event.payload ?? {};
+      const referenceId = typeof payload.referenceId === "string" ? payload.referenceId : void 0;
+      const estimatedLux = typeof payload.estimatedLux === "number" && Number.isFinite(payload.estimatedLux) ? payload.estimatedLux : void 0;
+      const colorTemperatureK = typeof payload.colorTemperatureK === "number" && Number.isFinite(payload.colorTemperatureK) ? payload.colorTemperatureK : void 0;
+      const dominantDirection = Array.isArray(payload.dominantDirection) ? payload.dominantDirection : void 0;
+      if (!referenceId) return;
+      state.lighting = {
+        reference_id: referenceId,
+        estimated_lux: estimatedLux,
+        color_temperature_k: colorTemperatureK,
+        dominant_direction: dominantDirection
+      };
+      state.profile = createBotanicalLotusRenderProfile(state.config, state.placement, state.lighting);
+      context.emit?.("botanical_lotus_lighting_updated", {
+        node,
+        referenceId,
+        estimatedLux,
+        colorTemperatureK,
+        dominantDirection
+      });
+      return;
+    }
+    if (event.type === "holomap:anchor_state_changed") {
+      const payload = event.payload ?? {};
+      const anchorFrameIndex = typeof payload.anchorFrameIndex === "number" ? payload.anchorFrameIndex : void 0;
+      if (state.placement?.surface_anchor_id && anchorFrameIndex !== void 0) {
+        context.emit?.("botanical_lotus_anchor_drift", {
+          node,
+          surfaceAnchorId: state.placement.surface_anchor_id,
+          anchorFrameIndex
+        });
+      }
+      return;
+    }
+  }
+};
+
+export { DEFAULT_BOTANICAL_LOTUS_CONFIG, assertBotanicalLotusConfig, botanicalLotusHandler, createBotanicalLotusRenderProfile, deriveBotanicalLotusAnchorStatus, getBotanicalLotusPetalCount, normalizeBotanicalLotusConfig, validateBotanicalLotusConfig };
+//# sourceMappingURL=chunk-VECQYRXL.js.map
+//# sourceMappingURL=chunk-VECQYRXL.js.map

package/dist/chunk-VJ3L7CHT.cjs

@@ -0,0 +1,169 @@
+'use strict';
+
+// src/compiler/ReproducibilityMode.ts
+var DEFAULT_FIXED_TIMESTAMP = "2026-01-01T00:00:00.000Z";
+var DEFAULT_SEED = 42;
+var DEFAULT_GENERATOR = "holoscript-compiler";
+var COMPILER_VERSION = "6.0.0";
+function createSeededRNG(seed = DEFAULT_SEED) {
+  let state = seed | 0;
+  const initialSeed = state;
+  function next() {
+    state = state + 1831565813 | 0;
+    let t = Math.imul(state ^ state >>> 15, 1 | state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  function nextInt(min, max) {
+    return Math.floor(next() * (max - min + 1)) + min;
+  }
+  function nextUUID() {
+    const hex = (n, len) => Array.from({ length: len }, () => nextInt(0, 15).toString(16)).join("");
+    return `${hex(0, 8)}-${hex(0, 4)}-4${hex(0, 3)}-${(8 + nextInt(0, 3)).toString(16)}${hex(0, 3)}-${hex(0, 12)}`;
+  }
+  function reset() {
+    state = initialSeed;
+  }
+  function getState() {
+    return state;
+  }
+  return { next, nextInt, nextUUID, reset, getState };
+}
+function sortKeysDeep(value) {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => sortKeysDeep(item));
+  }
+  if (typeof value === "object") {
+    const sorted = {};
+    const keys = Object.keys(value).sort();
+    for (const key of keys) {
+      sorted[key] = sortKeysDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function fnv1a32(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function hashComposition(composition) {
+  const sorted = sortKeysDeep(composition);
+  const serialized = JSON.stringify(sorted);
+  const h1 = fnv1a32(serialized);
+  const h2 = fnv1a32(serialized + h1);
+  const h3 = fnv1a32(serialized + h2);
+  const h4 = fnv1a32(serialized + h3);
+  const h5 = fnv1a32(serialized + h4);
+  const h6 = fnv1a32(serialized + h5);
+  const h7 = fnv1a32(serialized + h6);
+  const h8 = fnv1a32(serialized + h7);
+  return `${h1}${h2}${h3}${h4}${h5}${h6}${h7}${h8}`;
+}
+function createReproducibilityContext(config) {
+  const fullConfig = {
+    enabled: config.enabled,
+    fixedTimestamp: config.fixedTimestamp ?? DEFAULT_FIXED_TIMESTAMP,
+    randomSeed: config.randomSeed ?? DEFAULT_SEED,
+    sortKeys: config.sortKeys ?? config.enabled,
+    deterministicIds: config.deterministicIds ?? config.enabled,
+    generatorString: config.generatorString ?? DEFAULT_GENERATOR,
+    includeManifest: config.includeManifest ?? false
+  };
+  const rng = createSeededRNG(fullConfig.randomSeed);
+  function random() {
+    return fullConfig.enabled ? rng.next() : Math.random();
+  }
+  function randomInt(min, max) {
+    return fullConfig.enabled ? rng.nextInt(min, max) : Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+  function timestamp() {
+    return fullConfig.enabled ? fullConfig.fixedTimestamp : (/* @__PURE__ */ new Date()).toISOString();
+  }
+  function timestampDate() {
+    return fullConfig.enabled ? new Date(fullConfig.fixedTimestamp) : /* @__PURE__ */ new Date();
+  }
+  function uuid() {
+    if (!fullConfig.enabled || !fullConfig.deterministicIds) {
+      return crypto?.randomUUID?.() ?? rng.nextUUID();
+    }
+    return rng.nextUUID();
+  }
+  function generator() {
+    return fullConfig.generatorString;
+  }
+  function stabilize(value) {
+    if (!fullConfig.enabled || !fullConfig.sortKeys) return value;
+    return sortKeysDeep(value);
+  }
+  function manifest(composition) {
+    return {
+      reproducible: true,
+      seed: fullConfig.randomSeed,
+      timestamp: fullConfig.fixedTimestamp,
+      inputHash: hashComposition(composition),
+      compilerVersion: COMPILER_VERSION
+    };
+  }
+  function reset() {
+    rng.reset();
+  }
+  function stringify(value, indent = 2) {
+    const processed = fullConfig.enabled && fullConfig.sortKeys ? sortKeysDeep(value) : value;
+    return JSON.stringify(processed, null, indent);
+  }
+  return {
+    enabled: fullConfig.enabled,
+    config: fullConfig,
+    random,
+    randomInt,
+    timestamp,
+    timestampDate,
+    uuid,
+    generator,
+    stabilize,
+    manifest,
+    reset,
+    stringify
+  };
+}
+function parseReproducibilityFlags(args) {
+  const config = { enabled: false };
+  for (const arg of args) {
+    if (arg === "--reproducible") {
+      config.enabled = true;
+    }
+    if (arg === "--no-reproducible") {
+      config.enabled = false;
+    }
+    if (arg.startsWith("--reproducible-seed=")) {
+      config.enabled = true;
+      config.randomSeed = parseInt(arg.split("=")[1], 10);
+      if (isNaN(config.randomSeed)) config.randomSeed = DEFAULT_SEED;
+    }
+    if (arg.startsWith("--reproducible-timestamp=")) {
+      config.enabled = true;
+      config.fixedTimestamp = arg.split("=")[1].replace(/"/g, "");
+    }
+    if (arg === "--reproducible-manifest") {
+      config.includeManifest = true;
+    }
+  }
+  return config;
+}
+var ReproducibilityMode_default = createReproducibilityContext;
+
+exports.ReproducibilityMode_default = ReproducibilityMode_default;
+exports.createReproducibilityContext = createReproducibilityContext;
+exports.createSeededRNG = createSeededRNG;
+exports.fnv1a32 = fnv1a32;
+exports.hashComposition = hashComposition;
+exports.parseReproducibilityFlags = parseReproducibilityFlags;
+exports.sortKeysDeep = sortKeysDeep;
+//# sourceMappingURL=chunk-VJ3L7CHT.cjs.map
+//# sourceMappingURL=chunk-VJ3L7CHT.cjs.map