@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-A6KINLZJ.js

@@ -0,0 +1,236 @@
+// src/resilience/ResiliencePatterns.ts
+var CircuitBreakerState = /* @__PURE__ */ ((CircuitBreakerState2) => {
+  CircuitBreakerState2["CLOSED"] = "CLOSED";
+  CircuitBreakerState2["OPEN"] = "OPEN";
+  CircuitBreakerState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitBreakerState2;
+})(CircuitBreakerState || {});
+var CircuitBreaker = class {
+  constructor(config = {}) {
+    this.state = "CLOSED" /* CLOSED */;
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.lastFailureTime = null;
+    this.failures = [];
+    this.config = {
+      failureThreshold: 5,
+      successThreshold: 2,
+      resetTimeoutMs: 6e4,
+      // 1 minute
+      windowMs: 3e4,
+      // 30 seconds
+      isRetryable: (err) => err instanceof Error,
+      ...config
+    };
+  }
+  /**
+   * Execute function with circuit breaker protection
+   */
+  async execute(fn) {
+    if (this.state === "OPEN" /* OPEN */) {
+      if (Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN" /* HALF_OPEN */;
+        this.successCount = 0;
+      } else {
+        throw new Error(`Circuit breaker is OPEN. Retry after ${this.config.resetTimeoutMs}ms`);
+      }
+    }
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure(error);
+      throw error;
+    }
+  }
+  onSuccess() {
+    this.failureCount = 0;
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.config.successThreshold) {
+        this.state = "CLOSED" /* CLOSED */;
+      }
+    }
+  }
+  onFailure(error) {
+    this.lastFailureTime = Date.now();
+    this.failureCount++;
+    this.failures.push({ timestamp: Date.now(), error });
+    this.failures = this.failures.filter((f) => Date.now() - f.timestamp < this.config.windowMs);
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.state = "OPEN" /* OPEN */;
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.state = "OPEN" /* OPEN */;
+      console.error(`Circuit breaker OPEN after ${this.failureCount} failures: ${error.message}`);
+    }
+  }
+  get currentState() {
+    return this.state;
+  }
+  /**
+   * Get current circuit breaker state (accessor method)
+   */
+  getState() {
+    if (this.state === "OPEN" /* OPEN */ && Date.now() - (this.lastFailureTime || 0) > this.config.resetTimeoutMs) {
+      return "HALF_OPEN" /* HALF_OPEN */;
+    }
+    return this.state;
+  }
+  /**
+   * Get circuit breaker metrics
+   */
+  getMetrics() {
+    return {
+      state: this.state,
+      totalFailures: this.failureCount,
+      totalSuccesses: this.successCount,
+      lastFailureTime: this.lastFailureTime,
+      totalRequests: this.failureCount + this.successCount
+    };
+  }
+};
+async function retryWithBackoff(fn, config = {}) {
+  const cfg = {
+    maxAttempts: 3,
+    initialBackoffMs: 100,
+    maxBackoffMs: 1e4,
+    multiplier: 2,
+    jitter: true,
+    isRetryable: (err, attempt) => attempt < cfg.maxAttempts,
+    ...config
+  };
+  let lastError = null;
+  for (let attempt = 1; attempt <= cfg.maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!cfg.isRetryable(lastError, attempt)) {
+        throw lastError;
+      }
+      if (attempt < cfg.maxAttempts) {
+        const backoff = Math.min(
+          cfg.initialBackoffMs * Math.pow(cfg.multiplier, attempt - 1),
+          cfg.maxBackoffMs
+        );
+        const jitteredBackoff = cfg.jitter ? backoff * (0.5 + Math.random() * 0.5) : backoff;
+        console.warn(
+          `Attempt ${attempt} failed: ${lastError.message}. Retrying in ${Math.round(jitteredBackoff)}ms`
+        );
+        await sleep(jitteredBackoff);
+      }
+    }
+  }
+  throw lastError || new Error("Max retry attempts exceeded");
+}
+var Bulkhead = class {
+  constructor(config = {}) {
+    this.running = 0;
+    this.queue = [];
+    this.config = {
+      maxConcurrent: 10,
+      queueSize: 100,
+      timeoutMs: 3e4,
+      ...config
+    };
+  }
+  /**
+   * Execute function within bulkhead
+   */
+  async execute(fn) {
+    if (this.queue.length >= this.config.queueSize) {
+      throw new Error("Bulkhead queue full - too many pending operations");
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const idx = this.queue.findIndex((item) => item.resolve === resolve);
+        if (idx !== -1) {
+          this.queue.splice(idx, 1);
+        }
+        reject(new Error("Bulkhead operation timeout"));
+      }, this.config.timeoutMs);
+      this.queue.push({
+        fn,
+        // @ts-expect-error
+        resolve,
+        reject,
+        timeoutId
+      });
+      this.processQueue();
+    });
+  }
+  processQueue() {
+    while (this.running < this.config.maxConcurrent && this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      this.running++;
+      item.fn().then((result) => {
+        clearTimeout(item.timeoutId);
+        item.resolve(result);
+      }).catch((error) => {
+        clearTimeout(item.timeoutId);
+        item.reject(error);
+      }).finally(() => {
+        this.running--;
+        this.processQueue();
+      });
+    }
+  }
+  get stats() {
+    return {
+      running: this.running,
+      queued: this.queue.length
+    };
+  }
+  /**
+   * Get bulkhead state (accessor method)
+   */
+  getState() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+  /**
+   * Get bulkhead metrics
+   */
+  getMetrics() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      utilizationPercent: this.running / this.config.maxConcurrent * 100,
+      queueUtilizationPercent: this.queue.length / this.config.queueSize * 100
+    };
+  }
+};
+async function fallbackChain(strategies) {
+  let lastError = null;
+  for (let i = 0; i < strategies.length; i++) {
+    try {
+      const result = await strategies[i]();
+      return result;
+    } catch (error) {
+      lastError = error;
+      console.warn(`Strategy ${i + 1} failed: ${lastError.message}`);
+    }
+  }
+  throw lastError || new Error("All fallback strategies failed");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, timeoutMs) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeoutMs}ms`)), timeoutMs)
+    )
+  ]);
+}
+
+export { Bulkhead, CircuitBreaker, CircuitBreakerState, fallbackChain, retryWithBackoff, withTimeout };
+//# sourceMappingURL=chunk-A6KINLZJ.js.map
+//# sourceMappingURL=chunk-A6KINLZJ.js.map

package/dist/chunk-ADADVMXY.js

@@ -0,0 +1,404 @@
+import { z } from 'zod';
+
+// src/compiler/BusinessQuestTools.ts
+var vrrQuestEntrySchema = z.object({
+  id: z.string().min(1),
+  title: z.string().min(1),
+  steps: z.array(z.string()).min(1)
+});
+var businessVRRDraftSchema = z.object({
+  compositionName: z.string().min(1).regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "compositionName must be a valid HoloScript identifier"),
+  twin: z.object({
+    mirrorId: z.string().min(1),
+    realitySync: z.array(z.string()).min(1),
+    geoSync: z.object({
+      center: z.string().min(1),
+      radius: z.number().nonnegative().optional()
+    }).optional()
+  }),
+  weather: z.object({
+    provider: z.enum(["weather.gov", "openweathermap"]),
+    refresh: z.string().optional()
+  }).optional(),
+  events: z.object({
+    provider: z.enum(["eventbrite", "ticketmaster"]),
+    refresh: z.string().optional()
+  }).optional(),
+  businesses: z.array(
+    z.object({
+      id: z.string().min(1),
+      displayName: z.string().optional(),
+      geo: z.object({
+        lat: z.number().gte(-90).lte(90),
+        lng: z.number().gte(-180).lte(180)
+      }),
+      inventory: z.object({
+        provider: z.enum(["square_pos", "shopify", "woocommerce"]),
+        refresh: z.string().optional(),
+        websocket: z.boolean().optional()
+      }).optional(),
+      quests: z.array(vrrQuestEntrySchema).min(1)
+    })
+  ).min(1),
+  layerShift: z.object({
+    from: z.enum(["ar", "vrr", "vr"]),
+    to: z.enum(["ar", "vrr", "vr"]),
+    price: z.number().nonnegative().optional(),
+    persistState: 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.js').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.js');
+    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;
+
+export { BUSINESS_QUEST_TOOLS, BusinessQuestTools_default, buildVRRCompositionFromDraft, businessVRRDraftSchema, draftToHoloPreview, handleBusinessQuestToolCall, registerBusinessQuestTools, validateBusinessVRRDraft };
+//# sourceMappingURL=chunk-ADADVMXY.js.map
+//# sourceMappingURL=chunk-ADADVMXY.js.map