@holoscript/core 6.0.3 → 6.1.1

package/dist/chunk-4PDEPEQW.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+// src/traits/SimulationSolverFactory.ts
+var factories = /* @__PURE__ */ new Map();
+var SimulationSolverFactory = {
+  /**
+   * Register a solver constructor for a simulation type.
+   * Called by engine on app startup.
+   *
+   * @example
+   * SimulationSolverFactory.register('thermal', (cfg) => new ThermalSolver(cfg));
+   */
+  register(type, factory) {
+    factories.set(type, factory);
+  },
+  /**
+   * Create a solver instance. Returns null if no factory registered for type.
+   * Called by trait handlers in onAttach.
+   */
+  create(type, config) {
+    const factory = factories.get(type);
+    if (!factory) return null;
+    return factory(config);
+  },
+  /** Check if a solver type has a registered factory. */
+  has(type) {
+    return factories.has(type);
+  },
+  /** List all registered solver types. */
+  types() {
+    return [...factories.keys()];
+  },
+  /** Clear all registrations (for testing). */
+  clear() {
+    factories.clear();
+  }
+};
+
+exports.SimulationSolverFactory = SimulationSolverFactory;
+//# sourceMappingURL=chunk-4PDEPEQW.cjs.map
+//# sourceMappingURL=chunk-4PDEPEQW.cjs.map

package/dist/chunk-4R6SBXDB.js

@@ -0,0 +1,45 @@
+import { createHash } from 'crypto';
+
+// src/deploy/provenance.ts
+function computeContentHash(source) {
+  const normalized = source.replace(/\r\n/g, "\n");
+  return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+function classifyPublishMode(ast) {
+  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
+  const hasImports = Array.isArray(imports) && imports.length > 0;
+  if (!hasImports) return "original";
+  const body = ast?.body ?? ast?.ast?.body ?? [];
+  const hasOwnContent = Array.isArray(body) && body.some(
+    (node) => node.type === "composition" || node.type === "ObjectDeclaration" || node.type === "scene" || node.type === "object" || node.type === "character" || node.type === "environment"
+  );
+  if (hasOwnContent) return "remix";
+  return "curated";
+}
+function extractImports(ast) {
+  const imports = ast?.imports ?? ast?.ast?.imports ?? [];
+  if (!Array.isArray(imports)) return [];
+  return imports.map((imp) => ({
+    // @ts-expect-error
+    path: imp.path ?? imp.source ?? "",
+    // @ts-expect-error
+    hash: imp.hash,
+    // @ts-expect-error
+    author: imp.author
+  })).filter((imp) => imp.path.length > 0);
+}
+function generateProvenance(source, ast, options) {
+  return {
+    author: options.author,
+    created: options.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    hash: computeContentHash(source),
+    license: options.license,
+    version: 1,
+    publishMode: classifyPublishMode(ast),
+    imports: extractImports(ast)
+  };
+}
+
+export { classifyPublishMode, computeContentHash, extractImports, generateProvenance };
+//# sourceMappingURL=chunk-4R6SBXDB.js.map
+//# sourceMappingURL=chunk-4R6SBXDB.js.map

package/dist/chunk-4SY77NA4.cjs

@@ -0,0 +1,413 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/compiler/BusinessQuestTools.ts
+var vrrQuestEntrySchema = zod.z.object({
+  id: zod.z.string().min(1),
+  title: zod.z.string().min(1),
+  steps: zod.z.array(zod.z.string()).min(1)
+});
+var businessVRRDraftSchema = zod.z.object({
+  compositionName: zod.z.string().min(1).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "compositionName must be a valid HoloScript identifier"),
+  twin: zod.z.object({
+    mirrorId: zod.z.string().min(1),
+    realitySync: zod.z.array(zod.z.string()).min(1),
+    geoSync: zod.z.object({
+      center: zod.z.string().min(1),
+      radius: zod.z.number().nonnegative().optional()
+    }).optional()
+  }),
+  weather: zod.z.object({
+    provider: zod.z.enum(["weather.gov", "openweathermap"]),
+    refresh: zod.z.string().optional()
+  }).optional(),
+  events: zod.z.object({
+    provider: zod.z.enum(["eventbrite", "ticketmaster"]),
+    refresh: zod.z.string().optional()
+  }).optional(),
+  businesses: zod.z.array(
+    zod.z.object({
+      id: zod.z.string().min(1),
+      displayName: zod.z.string().optional(),
+      geo: zod.z.object({
+        lat: zod.z.number().gte(-90).lte(90),
+        lng: zod.z.number().gte(-180).lte(180)
+      }),
+      inventory: zod.z.object({
+        provider: zod.z.enum(["square_pos", "shopify", "woocommerce"]),
+        refresh: zod.z.string().optional(),
+        websocket: zod.z.boolean().optional()
+      }).optional(),
+      quests: zod.z.array(vrrQuestEntrySchema).min(1)
+    })
+  ).min(1),
+  layerShift: zod.z.object({
+    from: zod.z.enum(["ar", "vrr", "vr"]),
+    to: zod.z.enum(["ar", "vrr", "vr"]),
+    price: zod.z.number().nonnegative().optional(),
+    persistState: zod.z.boolean().optional()
+  }).optional()
+});
+function vrrTrait(name, params) {
+  return {
+    type: "ObjectTrait",
+    name,
+    config: params,
+    params
+  };
+}
+function emptyCompositionShell(name) {
+  return {
+    type: "Composition",
+    name,
+    templates: [],
+    objects: [],
+    spatialGroups: [],
+    lights: [],
+    imports: [],
+    timelines: [],
+    audio: [],
+    zones: [],
+    transitions: [],
+    conditionals: [],
+    iterators: [],
+    npcs: [],
+    quests: [],
+    abilities: [],
+    dialogues: [],
+    stateMachines: [],
+    achievements: [],
+    talentTrees: [],
+    shapes: [],
+    metadata: {
+      source: "business-quest-tools",
+      draftKind: "hololand-vrr"
+    }
+  };
+}
+function buildVRRCompositionFromDraft(draft) {
+  const composition = emptyCompositionShell(draft.compositionName);
+  const twinTraits = [
+    vrrTrait("vrr_twin", { mirror: draft.twin.mirrorId }),
+    vrrTrait("reality_mirror", { sync: draft.twin.realitySync })
+  ];
+  if (draft.twin.geoSync) {
+    twinTraits.push(
+      vrrTrait("geo_sync", {
+        center: draft.twin.geoSync.center,
+        radius: draft.twin.geoSync.radius ?? 0
+      })
+    );
+  }
+  const twinObject = {
+    type: "Object",
+    name: `${draft.compositionName}_twin_root`,
+    properties: [],
+    traits: twinTraits
+  };
+  const objects = [twinObject];
+  if (draft.weather) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_weather`,
+      properties: [],
+      traits: [
+        vrrTrait("weather_sync", {
+          provider: draft.weather.provider,
+          refresh: draft.weather.refresh ?? "5_minutes"
+        })
+      ]
+    });
+  }
+  if (draft.events) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_events`,
+      properties: [],
+      traits: [
+        vrrTrait("event_sync", {
+          provider: draft.events.provider,
+          refresh: draft.events.refresh ?? "5_minutes"
+        })
+      ]
+    });
+  }
+  for (const biz of draft.businesses) {
+    const questPayload = biz.quests.map((q) => ({
+      id: q.id,
+      title: q.title,
+      steps: q.steps
+    }));
+    const bizTraits = [
+      vrrTrait("geo_anchor", { lat: biz.geo.lat, lng: biz.geo.lng }),
+      vrrTrait("quest_hub", { quests: questPayload })
+    ];
+    if (biz.inventory) {
+      bizTraits.push(
+        vrrTrait("inventory_sync", {
+          provider: biz.inventory.provider,
+          refresh: biz.inventory.refresh ?? "1_minute",
+          websocket: biz.inventory.websocket ?? false
+        })
+      );
+    }
+    objects.push({
+      type: "Object",
+      name: biz.displayName ?? biz.id,
+      properties: [],
+      traits: bizTraits
+    });
+  }
+  if (draft.layerShift) {
+    objects.push({
+      type: "Object",
+      name: `${draft.compositionName}_layer_shift`,
+      properties: [],
+      traits: [
+        vrrTrait("layer_shift", {
+          from: draft.layerShift.from,
+          to: draft.layerShift.to,
+          price: draft.layerShift.price ?? 0,
+          persist_state: draft.layerShift.persistState !== false
+        })
+      ]
+    });
+  }
+  composition.objects = objects;
+  return composition;
+}
+function validateBusinessVRRDraft(draft, options) {
+  const issues = [];
+  const parsed = businessVRRDraftSchema.safeParse(draft);
+  if (!parsed.success) {
+    for (const err of parsed.error.issues) {
+      issues.push({
+        path: err.path.join("."),
+        message: err.message,
+        severity: "error"
+      });
+    }
+    return Promise.resolve({ ok: false, issues });
+  }
+  if (options?.parseWithVrrCompiler) {
+    return import('./compiler/vrr.cjs').then(({ VRRCompiler }) => {
+      const composition = buildVRRCompositionFromDraft(parsed.data);
+      const compiler = new VRRCompiler({
+        target: "threejs",
+        minify: false,
+        source_maps: false,
+        api_integrations: {},
+        performance: { target_fps: 60, max_players: 1e3, lazy_loading: true }
+      });
+      const data = compiler.parseVRRComposition(composition);
+      if (data.questNodes.length === 0) {
+        issues.push({
+          path: "businesses",
+          message: "VRR parse found no @quest_hub nodes \u2014 check draft.quests",
+          severity: "warning"
+        });
+      }
+      if (data.twinNodes.length === 0) {
+        issues.push({
+          path: "twin",
+          message: "VRR parse found no @vrr_twin nodes",
+          severity: "warning"
+        });
+      }
+      return { ok: issues.every((i) => i.severity !== "error"), issues };
+    }).catch((err) => {
+      issues.push({
+        path: "",
+        message: err instanceof Error ? err.message : String(err),
+        severity: "error"
+      });
+      return { ok: false, issues };
+    });
+  }
+  return Promise.resolve({ ok: true, issues });
+}
+function draftToHoloPreview(draft) {
+  const lines = [];
+  lines.push(`// Preview \u2014 generated by BusinessQuestTools (no-code VRR draft)`);
+  lines.push(`composition "${draft.compositionName}" {`);
+  lines.push(
+    `  // twin: mirror=${draft.twin.mirrorId} sync=[${draft.twin.realitySync.join(", ")}]`
+  );
+  if (draft.weather) {
+    lines.push(`  // weather: ${draft.weather.provider}`);
+  }
+  if (draft.events) {
+    lines.push(`  // events: ${draft.events.provider}`);
+  }
+  for (const biz of draft.businesses) {
+    lines.push(`  // business "${biz.id}" @ geo ${biz.geo.lat},${biz.geo.lng}`);
+    for (const q of biz.quests) {
+      lines.push(`  //   quest "${q.title}" (${q.steps.length} steps)`);
+    }
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+var BUSINESS_QUEST_TOOLS = [
+  {
+    name: "holoscript_business_quest_scaffold_vrr",
+    description: "Build a HoloComposition JSON for Hololand VRR from a structured draft (no .holo source). Includes @vrr_twin, @reality_mirror, optional @geo_sync, @weather_sync, @event_sync, per-business @geo_anchor + @quest_hub + optional @inventory_sync, and optional @layer_shift.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: {
+          type: "object",
+          description: "BusinessVRRDraft \u2014 see businessVRRDraftSchema in @holoscript/core"
+        },
+        runVrrParse: {
+          type: "boolean",
+          description: "If true, run VRRCompiler.parseVRRComposition and return trait counts",
+          default: false
+        },
+        agentToken: {
+          type: "string",
+          description: "Optional agent token for future RBAC (reserved)"
+        }
+      },
+      required: ["draft"]
+    }
+  },
+  {
+    name: "holoscript_business_quest_validate_vrr_draft",
+    description: "Validate a BusinessVRRDraft (Zod). Optionally run VRRCompiler parse smoke check.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: { type: "object", description: "Candidate BusinessVRRDraft JSON" },
+        parseWithVrrCompiler: {
+          type: "boolean",
+          description: "When true, dynamically loads VRRCompiler for wiring verification",
+          default: false
+        }
+      },
+      required: ["draft"]
+    }
+  },
+  {
+    name: "holoscript_business_quest_preview_holo",
+    description: "Return a commented HoloScript-style preview string for founder review (not a full parser round-trip).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        draft: { type: "object" }
+      },
+      required: ["draft"]
+    }
+  }
+];
+async function handleBusinessQuestToolCall(request) {
+  try {
+    switch (request.name) {
+      case "holoscript_business_quest_scaffold_vrr":
+        return await handleScaffold(request.arguments);
+      case "holoscript_business_quest_validate_vrr_draft":
+        return await handleValidate(request.arguments);
+      case "holoscript_business_quest_preview_holo":
+        return await handlePreview(request.arguments);
+      default:
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Unknown tool: ${request.name}` }]
+        };
+    }
+  } catch (error) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ]
+    };
+  }
+}
+async function handleScaffold(args) {
+  const parsed = businessVRRDraftSchema.safeParse(args.draft);
+  if (!parsed.success) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: JSON.stringify(parsed.error.flatten(), null, 2) }]
+    };
+  }
+  const composition = buildVRRCompositionFromDraft(parsed.data);
+  const runParse = Boolean(args.runVrrParse);
+  let vrrSummary;
+  if (runParse) {
+    const { VRRCompiler } = await import('./compiler/vrr.cjs');
+    const compiler = new VRRCompiler({
+      target: "threejs",
+      minify: false,
+      source_maps: false,
+      api_integrations: {},
+      performance: { target_fps: 60, max_players: 1e3, lazy_loading: true }
+    });
+    const data = compiler.parseVRRComposition(composition);
+    vrrSummary = {
+      twinNodes: data.twinNodes.length,
+      weatherNodes: data.weatherNodes.length,
+      eventNodes: data.eventNodes.length,
+      inventoryNodes: data.inventoryNodes.length,
+      questNodes: data.questNodes.length,
+      layerShiftNodes: data.layerShiftNodes.length,
+      paywallNodes: data.paywallNodes.length,
+      geoAnchorNodes: data.geoAnchorNodes.length
+    };
+  }
+  const payload = {
+    success: true,
+    compositionName: composition.name,
+    objectCount: composition.objects.length,
+    composition,
+    vrrTraitCounts: vrrSummary
+  };
+  return {
+    isError: false,
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+async function handleValidate(args) {
+  const parseWithVrrCompiler = Boolean(args.parseWithVrrCompiler);
+  const result = await validateBusinessVRRDraft(args.draft, { parseWithVrrCompiler });
+  return {
+    isError: !result.ok,
+    content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+  };
+}
+async function handlePreview(args) {
+  const parsed = businessVRRDraftSchema.safeParse(args.draft);
+  if (!parsed.success) {
+    return {
+      isError: true,
+      content: [{ type: "text", text: JSON.stringify(parsed.error.flatten(), null, 2) }]
+    };
+  }
+  const text = draftToHoloPreview(parsed.data);
+  return {
+    isError: false,
+    content: [{ type: "text", text }]
+  };
+}
+function registerBusinessQuestTools(server) {
+  for (const tool of BUSINESS_QUEST_TOOLS) {
+    server.registerTool(tool, handleBusinessQuestToolCall);
+  }
+}
+var BusinessQuestTools_default = handleBusinessQuestToolCall;
+
+exports.BUSINESS_QUEST_TOOLS = BUSINESS_QUEST_TOOLS;
+exports.BusinessQuestTools_default = BusinessQuestTools_default;
+exports.buildVRRCompositionFromDraft = buildVRRCompositionFromDraft;
+exports.businessVRRDraftSchema = businessVRRDraftSchema;
+exports.draftToHoloPreview = draftToHoloPreview;
+exports.handleBusinessQuestToolCall = handleBusinessQuestToolCall;
+exports.registerBusinessQuestTools = registerBusinessQuestTools;
+exports.validateBusinessVRRDraft = validateBusinessVRRDraft;
+//# sourceMappingURL=chunk-4SY77NA4.cjs.map
+//# sourceMappingURL=chunk-4SY77NA4.cjs.map