@wairon/cli 5.1.1-dev.7 → 5.1.1-dev.8

package/dist/index.js

@@ -8,6 +8,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -1211,7 +1214,7 @@ var init_defaults = __esm({
       copilot: ".github/prompts",
       codex: ".codex/agents"
     };
-    WAIRON_VERSION = "5.1.1-dev.7";
+    WAIRON_VERSION = "5.1.1-dev.8";
     GITHUB_REPO = "SYW-Apps/Waffle-AIron";
     ARCHITECT_AGENT_ID = "agent-architect";
     ARCHITECT_TEMPLATE_ID = "architect";
@@ -3700,10 +3703,10 @@ function stepGraph(steps) {
     const s = byNum.get(n);
     if (s.type !== "parallel" || s.endStep === void 0 || !s.branches?.length) continue;
     const entries = s.branches.map((b) => b.step).sort((a, b) => a - b);
-    const join16 = fallNext(s.endStep);
+    const join17 = fallNext(s.endStep);
     for (let i = 0; i < entries.length; i++) {
       const armEnd = i + 1 < entries.length ? prevOf(entries[i + 1]) : s.endStep;
-      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join16);
+      if (armEnd !== void 0 && armEnd >= entries[i]) armEndJoin.set(armEnd, join17);
     }
   }
   const successorsOf = (n) => {
@@ -7029,11 +7032,11 @@ var init_narrative_antipatterns = __esm({
           const memberEdges = keys.flatMap((k) => (adjacency.get(k) ?? []).filter((e) => inScc.has(e.toKey)));
           if (memberEdges.length === 0) continue;
           const anchor = [...memberEdges].sort((a, b) => a.fromKey.localeCompare(b.fromKey))[0];
-          const path26 = [...keys].sort().join(" \u2192 ");
+          const path27 = [...keys].sort().join(" \u2192 ");
           ctx.addIssue(
             "warning",
             "UNCONDITIONAL_CALL_CYCLE",
-            `Call cycle with no guard: ${path26} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
+            `Call cycle with no guard: ${path27} \u2014 every call edge in this cycle is unavoidable on all paths of its narrative (e.g. step ${anchor.stepNumber} of "${anchor.methodName}" in "${anchor.impl.id}" always calls ${anchor.toLabel}). This recurses without a base case, by construction. Guard at least one edge with a branch/return before the call, or lint.allow with the termination argument.`,
             anchor.impl.id,
             memberEdges.some((e) => ctx.isImplementationDraft(e.impl))
           );
@@ -14936,6 +14939,41 @@ function findChainingParent(childRoot) {
   }
   return null;
 }
+function listChainedRoots(rootDir = getProjectRoot()) {
+  const root = path15.resolve(rootDir);
+  const found = [];
+  const visited = /* @__PURE__ */ new Set([root]);
+  const walk = (projectDir, depth) => {
+    if (depth > 32) return;
+    const specsDir = aiPathsAt(projectDir).specsDir();
+    if (!pathExists(specsDir)) return;
+    for (const file of listFilesRecursive(specsDir, ".yaml")) {
+      let raw;
+      try {
+        raw = readYamlFile(file);
+      } catch {
+        continue;
+      }
+      if (!raw || typeof raw !== "object" || !("parentSystem" in raw)) continue;
+      const projectPath = raw.projectPath;
+      if (typeof projectPath !== "string" || projectPath.trim() === "") continue;
+      let childDir;
+      try {
+        childDir = path15.resolve(projectDir, projectPath);
+      } catch {
+        continue;
+      }
+      if (projectPathEscapesRoot(root, projectPath, childDir)) continue;
+      if (visited.has(childDir)) continue;
+      if (!fs10.existsSync(childDir)) continue;
+      visited.add(childDir);
+      found.push(path15.relative(root, childDir).split(path15.sep).join("/"));
+      walk(childDir, depth + 1);
+    }
+  };
+  walk(root, 0);
+  return found;
+}
 function mergeMountRealizations(subs) {
   const result = [];
   const indexById = /* @__PURE__ */ new Map();
@@ -15952,7 +15990,7 @@ var init_specs2 = __esm({
         }
         return issues;
       }
-      saveSubsystemSpec(spec) {
+      saveSubsystemSpec(spec, opts) {
         const p = this.getSubsystemPath(spec.id);
         ensureDir(path15.dirname(p));
         const { prefix } = splitNamespace(spec.id);
@@ -15979,7 +16017,7 @@ var init_specs2 = __esm({
         if (existing) {
           specToWrite.createdAt = existing.createdAt;
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(SubsystemSpecSchema, specToWrite, "subsystem", spec.id));
         invalidateSpecCache();
       }
@@ -16040,7 +16078,7 @@ var init_specs2 = __esm({
             `component "${spec.id}" already exists at ${path15.relative(this.rootDir, p)} \u2014 the flat layout re-saves in place and never relocates the file. The subsystem field is now "${spec.subsystem}" (was "${existing.subsystem}").`
           );
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(ComponentSpecSchema, specToWrite, "component", spec.id));
         invalidateSpecCache();
         this.normalizeComponentLayout();
@@ -16169,7 +16207,7 @@ var init_specs2 = __esm({
             }
           }
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(InterfaceSpecSchema, specToWrite, "interface", spec.id));
         invalidateSpecCache();
         return notices;
@@ -16226,7 +16264,7 @@ var init_specs2 = __esm({
             specToWrite.status = existing.status;
           }
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(ImplementationSpecSchema, specToWrite, "implementation", spec.id));
         invalidateSpecCache();
         return notices;
@@ -16255,7 +16293,7 @@ var init_specs2 = __esm({
        * relocates an existing file — both are by design, but silent they read as
        * "the subsystem parameter was ignored".
        */
-      saveTypeSpec(spec) {
+      saveTypeSpec(spec, opts) {
         const notices = [];
         const existing = this.loadTypeSpec(spec.id);
         const group = spec.group || (existing ? existing.group : void 0);
@@ -16279,7 +16317,7 @@ var init_specs2 = __esm({
             specToWrite.group = relativizeId(existing.group, this.writePrefixFor(spec.id));
           }
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(TypeSpecSchema, specToWrite, "type", spec.id));
         invalidateSpecCache();
         return notices;
@@ -16302,7 +16340,7 @@ var init_specs2 = __esm({
       loadGroupSpec(id) {
         return this.scanAll().groups.find((g) => g.id === id) ?? null;
       }
-      saveGroupSpec(spec) {
+      saveGroupSpec(spec, opts) {
         const p = this.getGroupPath(spec.id);
         ensureDir(path15.dirname(p));
         const specToWrite = this.prepareGroupForWrite(spec);
@@ -16310,7 +16348,7 @@ var init_specs2 = __esm({
         if (existing) {
           specToWrite.createdAt = existing.createdAt;
         }
-        specToWrite.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        specToWrite.updatedAt = opts?.preserveUpdatedAt && existing?.updatedAt ? existing.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
         writeYamlFile(p, parseOrThrow(GroupSpecSchema, specToWrite, "group", spec.id));
         invalidateSpecCache();
       }
@@ -16411,26 +16449,34 @@ var init_specs2 = __esm({
         return [...out];
       }
       /** Set a single spec's status (bumps updatedAt). Caller invalidates the cache. */
+      /**
+       * Flip one spec's lifecycle status, changing nothing else — the lock's freeze.
+       *
+       * `preserveUpdatedAt` because this is MECHANICAL: no authored content moves,
+       * so re-stamping updatedAt would claim an edit that never happened and make a
+       * freeze read like a design change in review.
+       */
       applySpecStatus(kind, id, status) {
+        const keepStamp = { preserveUpdatedAt: true };
         switch (kind) {
           case "subsystem": {
             const s = this.loadSubsystemSpec(id);
-            if (s) this.saveSubsystemSpec({ ...s, status });
+            if (s) this.saveSubsystemSpec({ ...s, status }, keepStamp);
             break;
           }
           case "component": {
             const s = this.loadComponentSpec(id);
-            if (s) this.saveComponentSpec({ ...s, status });
+            if (s) this.saveComponentSpec({ ...s, status }, keepStamp);
             break;
           }
           case "interface": {
             const s = this.loadInterfaceSpec(id);
-            if (s) this.saveInterfaceSpec({ ...s, status });
+            if (s) this.saveInterfaceSpec({ ...s, status }, keepStamp);
             break;
           }
           case "implementation": {
             const s = this.loadImplementationSpec(id);
-            if (s) this.saveImplementationSpec({ ...s, status });
+            if (s) this.saveImplementationSpec({ ...s, status }, keepStamp);
             break;
           }
         }
@@ -17507,243 +17553,3606 @@ var init_domains = __esm({
   }
 });
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  AI_PATHS: () => AI_PATHS,
-  ARCHITECT_AGENT_ID: () => ARCHITECT_AGENT_ID,
-  ARCHITECT_TEMPLATE_ID: () => ARCHITECT_TEMPLATE_ID,
-  AgentBriefSchema: () => AgentBriefSchema,
-  AgentRecordSchema: () => AgentRecordSchema,
-  AgentStatusSchema: () => AgentStatusSchema,
-  AgentTemplateSchema: () => AgentTemplateSchema,
-  AssertionSelectorSchema: () => AssertionSelectorSchema,
-  BACKEND_COMMANDS: () => BACKEND_COMMANDS,
-  BUILTIN_PROFILES: () => BUILTIN_PROFILES,
-  BUILTIN_TYPES: () => BUILTIN_TYPES,
-  BoundaryItemSchema: () => BoundaryItemSchema,
-  BuiltinTargetConfigSchema: () => BuiltinTargetConfigSchema,
-  BuiltinTargetSchema: () => BuiltinTargetSchema,
-  BundleNotFoundError: () => BundleNotFoundError,
-  CONTEXT_PATHS: () => CONTEXT_PATHS,
-  CatchClauseSchema: () => CatchClauseSchema,
-  ClaudeExporter: () => ClaudeExporter,
-  ComplexityRuleConfigSchema: () => ComplexityRuleConfigSchema,
-  ComponentSpecSchema: () => ComponentSpecSchema,
-  ComponentTypeSchema: () => ComponentTypeSchema,
-  ConfigValidationError: () => ConfigValidationError,
-  ConformanceTierSchema: () => ConformanceTierSchema,
-  CustomExporter: () => CustomExporter,
-  CustomTargetConfigSchema: () => CustomTargetConfigSchema,
-  CustomTargetSchema: () => CustomTargetSchema,
-  DEFAULT_TARGET_DIRS: () => DEFAULT_TARGET_DIRS,
-  DatabaseSpecSchema: () => DatabaseSpecSchema,
-  DeclarativePackSchema: () => DeclarativePackSchema,
-  DesignDepthSchema: () => DesignDepthSchema,
-  DiagramConfigSchema: () => DiagramConfigSchema,
-  DispatchBindingSchema: () => DispatchBindingSchema,
-  DocumentationRuleConfigSchema: () => DocumentationRuleConfigSchema,
-  DomainSchema: () => DomainSchema,
-  DomainTypeSchema: () => DomainTypeSchema,
-  DurabilitySchema: () => DurabilitySchema,
-  EndpointSchema: () => EndpointSchema,
-  EventBindingSchema: () => EventBindingSchema,
-  ExtDataSchema: () => ExtDataSchema,
-  ExternalLinkSchema: () => ExternalLinkSchema,
-  ExternalLinkTypeSchema: () => ExternalLinkTypeSchema,
-  GITHUB_REPO: () => GITHUB_REPO,
-  GLOBAL_PACKS_DEFAULT: () => GLOBAL_PACKS_DEFAULT,
-  GeminiExporter: () => GeminiExporter,
-  GroupSpecSchema: () => GroupSpecSchema,
-  GuaranteeSchema: () => GuaranteeSchema,
-  HttpMethodSchema: () => HttpMethodSchema,
-  ImplementationSpecSchema: () => ImplementationSpecSchema,
-  InterfaceSpecSchema: () => InterfaceSpecSchema,
-  InvariantSchema: () => InvariantSchema,
-  LANGUAGE_MARKERS: () => LANGUAGE_MARKERS,
-  LanguagePackDefSchema: () => LanguagePackDefSchema,
-  LifecycleEntrypointSchema: () => LifecycleEntrypointSchema,
-  LintAllowSchema: () => LintAllowSchema,
-  LintConfigSchema: () => LintConfigSchema,
-  LoopKindSchema: () => LoopKindSchema,
-  MethodImplementationSchema: () => MethodImplementationSchema,
-  MethodParamSchema: () => MethodParamSchema,
-  MethodSignatureSchema: () => MethodSignatureSchema,
-  NamedOpenApiSpecSchema: () => NamedOpenApiSpecSchema,
-  NamingRuleConfigSchema: () => NamingRuleConfigSchema,
-  NarrativeDetailSchema: () => NarrativeDetailSchema,
-  NarrativeStepSchema: () => NarrativeStepSchema,
-  NarrativeStepTypeSchema: () => NarrativeStepTypeSchema,
-  OutputTargetSchema: () => OutputTargetSchema,
-  PACK_DIR_ENTRIES: () => PACK_DIR_ENTRIES,
-  PATTERN_TYPES: () => PATTERN_TYPES,
-  PROJECT_KINDS: () => PROJECT_KINDS,
-  PackAssertionSchema: () => PackAssertionSchema,
-  PackInstructionBlockSchema: () => PackInstructionBlockSchema,
-  PackSelectionSchema: () => PackSelectionSchema,
-  PackSkillSchema: () => PackSkillSchema,
-  ParallelBranchSchema: () => ParallelBranchSchema,
-  PathsConfigSchema: () => PathsConfigSchema,
-  PatternDefSchema: () => PatternDefSchema,
-  PatternRefSchema: () => PatternRefSchema,
-  PortalAuthSchema: () => PortalAuthSchema,
-  PortalAuthSchemeSchema: () => PortalAuthSchemeSchema,
-  PortalTypeSchema: () => PortalTypeSchema,
-  ProfileDefSchema: () => ProfileDefSchema,
-  ProfileSelectionSubjectSchema: () => ProfileSelectionSubjectSchema,
-  ProjectConfigSchema: () => ProjectConfigSchema,
-  ProjectNotInitializedError: () => ProjectNotInitializedError,
-  ProjectProfileSelectionSchema: () => ProjectProfileSelectionSchema,
-  PublicInterfaceSchema: () => PublicInterfaceSchema,
-  PublicInterfaceTypeSchema: () => PublicInterfaceTypeSchema,
-  RegistrySchema: () => RegistrySchema,
-  RequirementItemSchema: () => RequirementItemSchema,
-  RulesConfigSchema: () => RulesConfigSchema,
-  SCAN_EXCLUDE_DIRS: () => SCAN_EXCLUDE_DIRS,
-  SDD_RULES: () => SDD_RULES,
-  SEMANTIC_GUARANTEES: () => SEMANTIC_GUARANTEES,
-  SUPPORTED_ALIASES: () => SUPPORTED_ALIASES,
-  SURFACE_AUDIENCES: () => SURFACE_AUDIENCES,
-  SkillResourceNotFoundError: () => SkillResourceNotFoundError,
-  SpecIdSchema: () => SpecIdSchema,
-  SpecStatusSchema: () => SpecStatusSchema,
-  SpecWorkspace: () => SpecWorkspace,
-  SubsystemSpecSchema: () => SubsystemSpecSchema,
-  SurfaceAudienceSchema: () => SurfaceAudienceSchema,
-  SurfaceContractEntrySchema: () => SurfaceContractEntrySchema,
-  SurfaceOriginSchema: () => SurfaceOriginSchema,
-  SurfaceSnapshotSchema: () => SurfaceSnapshotSchema,
-  SurfaceTypeDefSchema: () => SurfaceTypeDefSchema,
-  SwitchCaseSchema: () => SwitchCaseSchema,
-  SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
-  SystemSpecSchema: () => SystemSpecSchema,
-  TargetConfigSchema: () => TargetConfigSchema,
-  TemplateNotFoundError: () => TemplateNotFoundError,
-  TemplateSchema: () => TemplateSchema,
-  TopologyConfigSchema: () => TopologyConfigSchema,
-  TransportSchema: () => TransportSchema,
-  TrustedLinkSchema: () => TrustedLinkSchema,
-  TypeFieldSchema: () => TypeFieldSchema,
-  TypeKindSchema: () => TypeKindSchema,
-  TypeMethodSchema: () => TypeMethodSchema,
-  TypeSpecSchema: () => TypeSpecSchema,
-  UNVERSIONED: () => UNVERSIONED,
-  UnknownAgentError: () => UnknownAgentError,
-  VariantDefSchema: () => VariantDefSchema,
-  WAIRON_MANAGED_BANNER: () => WAIRON_MANAGED_BANNER,
-  WAIRON_MANAGED_MARKER: () => WAIRON_MANAGED_MARKER,
-  WAIRON_VERSION: () => WAIRON_VERSION,
-  WaironError: () => WaironError,
-  activeTargetTypes: () => activeTargetTypes,
-  addFreeStandingDomain: () => addFreeStandingDomain,
-  aiDir: () => aiDir,
-  aiPathsAt: () => aiPathsAt,
-  applySpecStatus: () => applySpecStatus,
-  assertContainedProjectPath: () => assertContainedProjectPath,
-  assertProjectInitialized: () => assertProjectInitialized,
-  assertionFullCode: () => assertionFullCode,
-  audienceRank: () => audienceRank,
-  backendCommand: () => backendCommand,
-  backfillChainedSubprojectConfigs: () => backfillChainedSubprojectConfigs,
-  buildCanvasDataModel: () => buildCanvasDataModel,
-  buildGraphModel: () => buildGraphModel,
-  buildProjectGraph: () => buildProjectGraph,
-  buildRuleContext: () => buildRuleContext,
-  buildServerInstructions: () => buildServerInstructions2,
-  checkChildSurfaceFreshness: () => checkChildSurfaceFreshness,
-  checkSkillFreshness: () => checkSkillFreshness,
-  clearLoaderIssues: () => clearLoaderIssues,
-  collectPromotableSpecs: () => collectPromotableSpecs,
-  composeAgentBrief: () => composeAgentBrief,
-  composeRuleSequence: () => composeRuleSequence,
-  composeVariantGuidance: () => composeVariantGuidance,
-  computeGateStateId: () => computeGateStateId,
-  computePackDigest: () => computePackDigest,
-  computeParentStateId: () => computeParentStateId,
-  computeStateId: () => computeStateId,
-  computeStateIdAt: () => computeStateIdAt,
-  contextDir: () => contextDir,
-  createAgentRecord: () => createAgentRecord,
-  createChainedSubsystem: () => createChainedSubsystem,
-  createEmptyRegistry: () => createEmptyRegistry,
-  createEmptyTopologyConfig: () => createEmptyTopologyConfig,
-  defaultPackSelections: () => defaultPackSelections,
-  defaultTargetConfig: () => defaultTargetConfig,
-  deleteComponentSpec: () => deleteComponentSpec,
-  deleteGroupSpec: () => deleteGroupSpec,
-  deleteImplementationSpec: () => deleteImplementationSpec,
-  deleteInterfaceSpec: () => deleteInterfaceSpec,
-  deleteSubsystemSpec: () => deleteSubsystemSpec,
-  deleteTypeSpec: () => deleteTypeSpec,
-  deriveSubsystemDomains: () => deriveSubsystemDomains,
-  detectDomainCandidates: () => detectDomainCandidates,
-  diagnoseProjectPacks: () => diagnoseProjectPacks,
-  diagramSetIndex: () => diagramSetIndex,
-  discoverPacks: () => discoverPacks,
-  dryRunSerializeSpecs: () => dryRunSerializeSpecs,
-  emptyExtensions: () => emptyExtensions,
-  ensureDir: () => ensureDir,
-  ensureProjectInitialized: () => ensureProjectInitialized,
-  exportSddSkills: () => exportSddSkills,
-  exportSurface: () => exportSurface,
-  externalizeSubsystem: () => externalizeSubsystem,
-  extractGenericTypeVariables: () => extractGenericTypeVariables,
-  extractTypeGenerics: () => extractTypeGenerics,
-  extractTypeIdentifiers: () => extractTypeIdentifiers,
-  extractTypesFromSignature: () => extractTypesFromSignature,
-  findChainingParent: () => findChainingParent,
-  findChainingSubprojectsMissingConfig: () => findChainingSubprojectsMissingConfig,
-  findDomain: () => findDomain,
-  findLegacySpecFiles: () => findLegacySpecFiles,
-  findProjectRoot: () => findProjectRoot,
-  findSystemRoot: () => findSystemRoot,
-  fromOpenApi: () => fromOpenApi,
-  fromProjectRoot: () => fromProjectRoot,
-  generateAgent: () => generateAgent,
-  generateAll: () => generateAll,
-  generateChildSnapshots: () => generateChildSnapshots,
-  generateComponentDiagram: () => generateComponentDiagram,
-  generateDiagramSet: () => generateDiagramSet,
-  generateSequenceDiagram: () => generateSequenceDiagram,
-  getComponentPath: () => getComponentPath,
-  getExporter: () => getExporter,
-  getGroupPath: () => getGroupPath,
-  getImplementationPath: () => getImplementationPath,
-  getInterfacePath: () => getInterfacePath,
-  getLoaderIssues: () => getLoaderIssues,
-  getProjectRoot: () => getProjectRoot,
-  getProjectRootOverride: () => getProjectRootOverride,
-  getRequestProjectRoot: () => getRequestProjectRoot,
-  getSnapshot: () => getSnapshot,
-  getSubprojectPrefix: () => getSubprojectPrefix,
-  getSubsystemPath: () => getSubsystemPath,
-  getTypePath: () => getTypePath,
-  globalPacksDir: () => globalPacksDir,
-  globalPacksEnabled: () => globalPacksEnabled,
-  globalTemplatesDir: () => globalTemplatesDir,
-  globalVariantsDir: () => globalVariantsDir,
-  hasArchitectureContext: () => hasArchitectureContext,
-  hasContext: () => hasContext,
-  hashGateState: () => hashGateState,
-  importSurface: () => importSurface,
-  installPackFromDirectory: () => installPackFromDirectory,
-  internalizeSubsystem: () => internalizeSubsystem,
-  invalidateSpecCache: () => invalidateSpecCache,
-  isOpenApiDocument: () => isOpenApiDocument,
-  isProjectInitialized: () => isProjectInitialized,
-  listDirectChainedSubprojects: () => listDirectChainedSubprojects,
-  listExternalInterfaces: () => listExternalInterfaces,
-  listFiles: () => listFiles,
-  listFilesRecursive: () => listFilesRecursive,
-  listFreeStandingDomains: () => listFreeStandingDomains,
-  listInstalledPacks: () => listInstalledPacks,
-  listResources: () => listResources,
-  listRules: () => listRules,
-  listSkillNames: () => listSkillNames,
-  listSkillResources: () => listSkillResources,
-  listSnapshots: () => listSnapshots,
-  listTemplateIds: () => listTemplateIds,
-  loadAgentOverride: () => loadAgentOverride,
+// node_modules/fflate/lib/node.cjs
+var require_node = __commonJS({
+  "node_modules/fflate/lib/node.cjs"(exports2) {
+    "use strict";
+    exports2.deflate = deflate;
+    exports2.deflateSync = deflateSync;
+    exports2.inflate = inflate;
+    exports2.inflateSync = inflateSync;
+    exports2.gzip = gzip;
+    exports2.compress = gzip;
+    exports2.gzipSync = gzipSync;
+    exports2.compressSync = gzipSync;
+    exports2.gunzip = gunzip;
+    exports2.gunzipSync = gunzipSync;
+    exports2.zlib = zlib;
+    exports2.zlibSync = zlibSync;
+    exports2.unzlib = unzlib;
+    exports2.unzlibSync = unzlibSync;
+    exports2.gzip = gzip;
+    exports2.compress = gzip;
+    exports2.decompress = decompress;
+    exports2.decompressSync = decompressSync;
+    exports2.strToU8 = strToU8;
+    exports2.strFromU8 = strFromU8;
+    exports2.zip = zip;
+    exports2.zipSync = zipSync;
+    exports2.unzip = unzip;
+    exports2.unzipSync = unzipSync;
+    var _a;
+    var Worker;
+    var isMarkedAsUntransferable;
+    var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global";
+    try {
+      _a = require("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+    } catch (e) {
+    }
+    var node_worker_1 = {};
+    node_worker_1["default"] = Worker ? function(c, _, msg, transfer, cb) {
+      var done = false;
+      var w = new Worker(c + workerAdd, { eval: true }).on("error", function(e) {
+        return cb(e, null);
+      }).on("message", function(m) {
+        return cb(null, m);
+      }).on("exit", function(c2) {
+        if (c2 && !done)
+          cb(new Error("exited with code " + c2), null);
+      });
+      if (isMarkedAsUntransferable)
+        transfer = transfer.filter(function(t) {
+          return !isMarkedAsUntransferable(t);
+        });
+      w.postMessage(msg, transfer);
+      w.terminate = function() {
+        done = true;
+        return Worker.prototype.terminate.call(w);
+      };
+      return w;
+    } : function(_, __, ___, ____, cb) {
+      setImmediate(function() {
+        return cb(new Error("async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)"), null);
+      });
+      var NOP = function() {
+      };
+      return {
+        terminate: NOP,
+        postMessage: NOP
+      };
+    };
+    var u8 = Uint8Array;
+    var u16 = Uint16Array;
+    var i32 = Int32Array;
+    var fleb = new u8([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0,
+      /* unused */
+      0,
+      0,
+      /* impossible */
+      0
+    ]);
+    var fdeb = new u8([
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13,
+      /* unused */
+      0,
+      0
+    ]);
+    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    var freb = function(eb, start) {
+      var b = new u16(31);
+      for (var i2 = 0; i2 < 31; ++i2) {
+        b[i2] = start += 1 << eb[i2 - 1];
+      }
+      var r = new i32(b[30]);
+      for (var i2 = 1; i2 < 30; ++i2) {
+        for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+          r[j] = j - b[i2] << 5 | i2;
+        }
+      }
+      return { b, r };
+    };
+    var _a = freb(fleb, 2);
+    var fl = _a.b;
+    var revfl = _a.r;
+    fl[28] = 258, revfl[258] = 28;
+    var _b = freb(fdeb, 0);
+    var fd = _b.b;
+    var revfd = _b.r;
+    var rev = new u16(32768);
+    for (i = 0; i < 32768; ++i) {
+      x = (i & 43690) >> 1 | (i & 21845) << 1;
+      x = (x & 52428) >> 2 | (x & 13107) << 2;
+      x = (x & 61680) >> 4 | (x & 3855) << 4;
+      rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+    }
+    var x;
+    var i;
+    var hMap = (function(cd, mb, r) {
+      var s = cd.length;
+      var i2 = 0;
+      var l = new u16(mb);
+      for (; i2 < s; ++i2) {
+        if (cd[i2])
+          ++l[cd[i2] - 1];
+      }
+      var le = new u16(mb);
+      for (i2 = 1; i2 < mb; ++i2) {
+        le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
+      }
+      var co;
+      if (r) {
+        co = new u16(1 << mb);
+        var rvb = 15 - mb;
+        for (i2 = 0; i2 < s; ++i2) {
+          if (cd[i2]) {
+            var sv = i2 << 4 | cd[i2];
+            var r_1 = mb - cd[i2];
+            var v = le[cd[i2] - 1]++ << r_1;
+            for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+              co[rev[v] >> rvb] = sv;
+            }
+          }
+        }
+      } else {
+        co = new u16(s);
+        for (i2 = 0; i2 < s; ++i2) {
+          if (cd[i2]) {
+            co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
+          }
+        }
+      }
+      return co;
+    });
+    var flt = new u8(288);
+    for (i = 0; i < 144; ++i)
+      flt[i] = 8;
+    var i;
+    for (i = 144; i < 256; ++i)
+      flt[i] = 9;
+    var i;
+    for (i = 256; i < 280; ++i)
+      flt[i] = 7;
+    var i;
+    for (i = 280; i < 288; ++i)
+      flt[i] = 8;
+    var i;
+    var fdt = new u8(32);
+    for (i = 0; i < 32; ++i)
+      fdt[i] = 5;
+    var i;
+    var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+    var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
+    var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+    var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
+    var max = function(a) {
+      var m = a[0];
+      for (var i2 = 1; i2 < a.length; ++i2) {
+        if (a[i2] > m)
+          m = a[i2];
+      }
+      return m;
+    };
+    var bits = function(d, p, m) {
+      var o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+    };
+    var bits16 = function(d, p) {
+      var o = p / 8 | 0;
+      return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+    };
+    var shft = function(p) {
+      return (p + 7) / 8 | 0;
+    };
+    var slc = function(v, s, e) {
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      return new u8(v.subarray(s, e));
+    };
+    exports2.FlateErrorCode = {
+      UnexpectedEOF: 0,
+      InvalidBlockType: 1,
+      InvalidLengthLiteral: 2,
+      InvalidDistance: 3,
+      StreamFinished: 4,
+      NoStreamHandler: 5,
+      InvalidHeader: 6,
+      NoCallback: 7,
+      InvalidUTF8: 8,
+      ExtraFieldTooLong: 9,
+      InvalidDate: 10,
+      FilenameTooLong: 11,
+      StreamFinishing: 12,
+      InvalidZipData: 13,
+      UnknownCompressionMethod: 14
+    };
+    var ec = [
+      "unexpected EOF",
+      "invalid block type",
+      "invalid length/literal",
+      "invalid distance",
+      "stream finished",
+      "no stream handler",
+      ,
+      // determined by compression function
+      "no callback",
+      "invalid UTF-8 data",
+      "extra field too long",
+      "date not in range 1980-2099",
+      "filename too long",
+      "stream finishing",
+      "invalid zip data"
+      // determined by unknown compression method
+    ];
+    var err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    var inflt = function(dat, st, buf, dict) {
+      var sl = dat.length, dl = dict ? dict.length : 0;
+      if (!sl || st.f && !st.l)
+        return buf || new u8(0);
+      var noBuf = !buf;
+      var resize = noBuf || st.i != 2;
+      var noSt = st.i;
+      if (noBuf)
+        buf = new u8(sl * 3);
+      var cbuf = function(l2) {
+        var bl = buf.length;
+        if (l2 > bl) {
+          var nbuf = new u8(Math.max(bl * 2, l2));
+          nbuf.set(buf);
+          buf = nbuf;
+        }
+      };
+      var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+      var tbts = sl * 8;
+      do {
+        if (!lm) {
+          final = bits(dat, pos, 1);
+          var type = bits(dat, pos + 1, 3);
+          pos += 3;
+          if (!type) {
+            var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+            if (t > sl) {
+              if (noSt)
+                err(0);
+              break;
+            }
+            if (resize)
+              cbuf(bt + l);
+            buf.set(dat.subarray(s, t), bt);
+            st.b = bt += l, st.p = pos = t * 8, st.f = final;
+            continue;
+          } else if (type == 1)
+            lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+          else if (type == 2) {
+            var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+            var tl = hLit + bits(dat, pos + 5, 31) + 1;
+            pos += 14;
+            var ldt = new u8(tl);
+            var clt = new u8(19);
+            for (var i2 = 0; i2 < hcLen; ++i2) {
+              clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
+            }
+            pos += hcLen * 3;
+            var clb = max(clt), clbmsk = (1 << clb) - 1;
+            var clm = hMap(clt, clb, 1);
+            for (var i2 = 0; i2 < tl; ) {
+              var r = clm[bits(dat, pos, clbmsk)];
+              pos += r & 15;
+              var s = r >> 4;
+              if (s < 16) {
+                ldt[i2++] = s;
+              } else {
+                var c = 0, n = 0;
+                if (s == 16)
+                  n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
+                else if (s == 17)
+                  n = 3 + bits(dat, pos, 7), pos += 3;
+                else if (s == 18)
+                  n = 11 + bits(dat, pos, 127), pos += 7;
+                while (n--)
+                  ldt[i2++] = c;
+              }
+            }
+            var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+            lbt = max(lt);
+            dbt = max(dt);
+            lm = hMap(lt, lbt, 1);
+            dm = hMap(dt, dbt, 1);
+          } else
+            err(1);
+          if (pos > tbts) {
+            if (noSt)
+              err(0);
+            break;
+          }
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+        var lpos = pos;
+        for (; ; lpos = pos) {
+          var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+          pos += c & 15;
+          if (pos > tbts) {
+            if (noSt)
+              err(0);
+            break;
+          }
+          if (!c)
+            err(2);
+          if (sym < 256)
+            buf[bt++] = sym;
+          else if (sym == 256) {
+            lpos = pos, lm = null;
+            break;
+          } else {
+            var add = sym - 254;
+            if (sym > 264) {
+              var i2 = sym - 257, b = fleb[i2];
+              add = bits(dat, pos, (1 << b) - 1) + fl[i2];
+              pos += b;
+            }
+            var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+            if (!d)
+              err(3);
+            pos += d & 15;
+            var dt = fd[dsym];
+            if (dsym > 3) {
+              var b = fdeb[dsym];
+              dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+            }
+            if (pos > tbts) {
+              if (noSt)
+                err(0);
+              break;
+            }
+            if (resize)
+              cbuf(bt + 131072);
+            var end = bt + add;
+            if (bt < dt) {
+              var shift = dl - dt, dend = Math.min(dt, end);
+              if (shift + bt < 0)
+                err(3);
+              for (; bt < dend; ++bt)
+                buf[bt] = dict[shift + bt];
+            }
+            for (; bt < end; ++bt)
+              buf[bt] = buf[bt - dt];
+          }
+        }
+        st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+        if (lm)
+          final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+      } while (!final);
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+    };
+    var wbits = function(d, p, v) {
+      v <<= p & 7;
+      var o = p / 8 | 0;
+      d[o] |= v;
+      d[o + 1] |= v >> 8;
+    };
+    var wbits16 = function(d, p, v) {
+      v <<= p & 7;
+      var o = p / 8 | 0;
+      d[o] |= v;
+      d[o + 1] |= v >> 8;
+      d[o + 2] |= v >> 16;
+    };
+    var hTree = function(d, mb) {
+      var t = [];
+      for (var i2 = 0; i2 < d.length; ++i2) {
+        if (d[i2])
+          t.push({ s: i2, f: d[i2] });
+      }
+      var s = t.length;
+      var t2 = t.slice();
+      if (!s)
+        return { t: et, l: 0 };
+      if (s == 1) {
+        var v = new u8(t[0].s + 1);
+        v[t[0].s] = 1;
+        return { t: v, l: 1 };
+      }
+      t.sort(function(a, b) {
+        return a.f - b.f;
+      });
+      t.push({ s: -1, f: 25001 });
+      var l = t[0], r = t[1], i0 = 0, i1 = 1, i22 = 2;
+      t[0] = { s: -1, f: l.f + r.f, l, r };
+      while (i1 != s - 1) {
+        l = t[t[i0].f < t[i22].f ? i0++ : i22++];
+        r = t[i0 != i1 && t[i0].f < t[i22].f ? i0++ : i22++];
+        t[i1++] = { s: -1, f: l.f + r.f, l, r };
+      }
+      var maxSym = t2[0].s;
+      for (var i2 = 1; i2 < s; ++i2) {
+        if (t2[i2].s > maxSym)
+          maxSym = t2[i2].s;
+      }
+      var tr = new u16(maxSym + 1);
+      var mbt = ln(t[i1 - 1], tr, 0);
+      if (mbt > mb) {
+        var i2 = 0, dt = 0;
+        var lft = mbt - mb, cst = 1 << lft;
+        t2.sort(function(a, b) {
+          return tr[b.s] - tr[a.s] || a.f - b.f;
+        });
+        for (; i2 < s; ++i2) {
+          var i2_1 = t2[i2].s;
+          if (tr[i2_1] > mb) {
+            dt += cst - (1 << mbt - tr[i2_1]);
+            tr[i2_1] = mb;
+          } else
+            break;
+        }
+        dt >>= lft;
+        while (dt > 0) {
+          var i2_2 = t2[i2].s;
+          if (tr[i2_2] < mb)
+            dt -= 1 << mb - tr[i2_2]++ - 1;
+          else
+            ++i2;
+        }
+        for (; i2 >= 0 && dt; --i2) {
+          var i2_3 = t2[i2].s;
+          if (tr[i2_3] == mb) {
+            --tr[i2_3];
+            ++dt;
+          }
+        }
+        mbt = mb;
+      }
+      return { t: new u8(tr), l: mbt };
+    };
+    var ln = function(n, l, d) {
+      return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+    };
+    var lc = function(c) {
+      var s = c.length;
+      while (s && !c[--s])
+        ;
+      var cl = new u16(++s);
+      var cli = 0, cln = c[0], cls = 1;
+      var w = function(v) {
+        cl[cli++] = v;
+      };
+      for (var i2 = 1; i2 <= s; ++i2) {
+        if (c[i2] == cln && i2 != s)
+          ++cls;
+        else {
+          if (!cln && cls > 2) {
+            for (; cls > 138; cls -= 138)
+              w(32754);
+            if (cls > 2) {
+              w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+              cls = 0;
+            }
+          } else if (cls > 3) {
+            w(cln), --cls;
+            for (; cls > 6; cls -= 6)
+              w(8304);
+            if (cls > 2)
+              w(cls - 3 << 5 | 8208), cls = 0;
+          }
+          while (cls--)
+            w(cln);
+          cls = 1;
+          cln = c[i2];
+        }
+      }
+      return { c: cl.subarray(0, cli), n: s };
+    };
+    var clen = function(cf, cl) {
+      var l = 0;
+      for (var i2 = 0; i2 < cl.length; ++i2)
+        l += cf[i2] * cl[i2];
+      return l;
+    };
+    var wfblk = function(out, pos, dat) {
+      var s = dat.length;
+      var o = shft(pos + 2);
+      out[o] = s & 255;
+      out[o + 1] = s >> 8;
+      out[o + 2] = out[o] ^ 255;
+      out[o + 3] = out[o + 1] ^ 255;
+      for (var i2 = 0; i2 < s; ++i2)
+        out[o + i2 + 4] = dat[i2];
+      return (o + 4 + s) * 8;
+    };
+    var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+      wbits(out, p++, final);
+      ++lf[256];
+      var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+      var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+      var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+      var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+      var lcfreq = new u16(19);
+      for (var i2 = 0; i2 < lclt.length; ++i2)
+        ++lcfreq[lclt[i2] & 31];
+      for (var i2 = 0; i2 < lcdt.length; ++i2)
+        ++lcfreq[lcdt[i2] & 31];
+      var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+      var nlcc = 19;
+      for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+        ;
+      var flen = bl + 5 << 3;
+      var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+      if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+        return wfblk(out, p, dat.subarray(bs, bs + bl));
+      var lm, ll, dm, dl;
+      wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+      if (dtlen < ftlen) {
+        lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+        var llm = hMap(lct, mlcb, 0);
+        wbits(out, p, nlc - 257);
+        wbits(out, p + 5, ndc - 1);
+        wbits(out, p + 10, nlcc - 4);
+        p += 14;
+        for (var i2 = 0; i2 < nlcc; ++i2)
+          wbits(out, p + 3 * i2, lct[clim[i2]]);
+        p += 3 * nlcc;
+        var lcts = [lclt, lcdt];
+        for (var it = 0; it < 2; ++it) {
+          var clct = lcts[it];
+          for (var i2 = 0; i2 < clct.length; ++i2) {
+            var len = clct[i2] & 31;
+            wbits(out, p, llm[len]), p += lct[len];
+            if (len > 15)
+              wbits(out, p, clct[i2] >> 5 & 127), p += clct[i2] >> 12;
+          }
+        }
+      } else {
+        lm = flm, ll = flt, dm = fdm, dl = fdt;
+      }
+      for (var i2 = 0; i2 < li; ++i2) {
+        var sym = syms[i2];
+        if (sym > 255) {
+          var len = sym >> 18 & 31;
+          wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+          if (len > 7)
+            wbits(out, p, sym >> 23 & 31), p += fleb[len];
+          var dst = sym & 31;
+          wbits16(out, p, dm[dst]), p += dl[dst];
+          if (dst > 3)
+            wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+        } else {
+          wbits16(out, p, lm[sym]), p += ll[sym];
+        }
+      }
+      wbits16(out, p, lm[256]);
+      return p + ll[256];
+    };
+    var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+    var et = /* @__PURE__ */ new u8(0);
+    var dflt = function(dat, lvl, plvl, pre, post, st) {
+      var s = st.z || dat.length;
+      var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+      var w = o.subarray(pre, o.length - post);
+      var lst = st.l;
+      var pos = (st.r || 0) & 7;
+      if (lvl) {
+        if (pos)
+          w[0] = st.r >> 3;
+        var opt = deo[lvl - 1];
+        var n = opt >> 13, c = opt & 8191;
+        var msk_1 = (1 << plvl) - 1;
+        var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+        var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+        var hsh = function(i3) {
+          return (dat[i3] ^ dat[i3 + 1] << bs1_1 ^ dat[i3 + 2] << bs2_1) & msk_1;
+        };
+        var syms = new i32(25e3);
+        var lf = new u16(288), df = new u16(32);
+        var lc_1 = 0, eb = 0, i2 = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+        for (; i2 + 2 < s; ++i2) {
+          var hv = hsh(i2);
+          var imod = i2 & 32767, pimod = head[hv];
+          prev[imod] = pimod;
+          head[hv] = imod;
+          if (wi <= i2) {
+            var rem = s - i2;
+            if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+              pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i2 - bs, pos);
+              li = lc_1 = eb = 0, bs = i2;
+              for (var j = 0; j < 286; ++j)
+                lf[j] = 0;
+              for (var j = 0; j < 30; ++j)
+                df[j] = 0;
+            }
+            var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+            if (rem > 2 && hv == hsh(i2 - dif)) {
+              var maxn = Math.min(n, rem) - 1;
+              var maxd = Math.min(32767, i2);
+              var ml = Math.min(258, rem);
+              while (dif <= maxd && --ch_1 && imod != pimod) {
+                if (dat[i2 + l] == dat[i2 + l - dif]) {
+                  var nl = 0;
+                  for (; nl < ml && dat[i2 + nl] == dat[i2 + nl - dif]; ++nl)
+                    ;
+                  if (nl > l) {
+                    l = nl, d = dif;
+                    if (nl > maxn)
+                      break;
+                    var mmd = Math.min(dif, nl - 2);
+                    var md = 0;
+                    for (var j = 0; j < mmd; ++j) {
+                      var ti = i2 - dif + j & 32767;
+                      var pti = prev[ti];
+                      var cd = ti - pti & 32767;
+                      if (cd > md)
+                        md = cd, pimod = ti;
+                    }
+                  }
+                }
+                imod = pimod, pimod = prev[imod];
+                dif += imod - pimod & 32767;
+              }
+            }
+            if (d) {
+              syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+              var lin = revfl[l] & 31, din = revfd[d] & 31;
+              eb += fleb[lin] + fdeb[din];
+              ++lf[257 + lin];
+              ++df[din];
+              wi = i2 + l;
+              ++lc_1;
+            } else {
+              syms[li++] = dat[i2];
+              ++lf[dat[i2]];
+            }
+          }
+        }
+        for (i2 = Math.max(i2, wi); i2 < s; ++i2) {
+          syms[li++] = dat[i2];
+          ++lf[dat[i2]];
+        }
+        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i2 - bs, pos);
+        if (!lst) {
+          st.r = pos & 7 | w[pos / 8 | 0] << 3;
+          pos -= 7;
+          st.h = head, st.p = prev, st.i = i2, st.w = wi;
+        }
+      } else {
+        for (var i2 = st.w || 0; i2 < s + lst; i2 += 65535) {
+          var e = i2 + 65535;
+          if (e >= s) {
+            w[pos / 8 | 0] = lst;
+            e = s;
+          }
+          pos = wfblk(w, pos + 1, dat.subarray(i2, e));
+        }
+        st.i = s;
+      }
+      return slc(o, 0, pre + shft(pos) + post);
+    };
+    var crct = /* @__PURE__ */ (function() {
+      var t = new Int32Array(256);
+      for (var i2 = 0; i2 < 256; ++i2) {
+        var c = i2, k = 9;
+        while (--k)
+          c = (c & 1 && -306674912) ^ c >>> 1;
+        t[i2] = c;
+      }
+      return t;
+    })();
+    var crc = function() {
+      var c = -1;
+      return {
+        p: function(d) {
+          var cr = c;
+          for (var i2 = 0; i2 < d.length; ++i2)
+            cr = crct[cr & 255 ^ d[i2]] ^ cr >>> 8;
+          c = cr;
+        },
+        d: function() {
+          return ~c;
+        }
+      };
+    };
+    var adler = function() {
+      var a = 1, b = 0;
+      return {
+        p: function(d) {
+          var n = a, m = b;
+          var l = d.length | 0;
+          for (var i2 = 0; i2 != l; ) {
+            var e = Math.min(i2 + 2655, l);
+            for (; i2 < e; ++i2)
+              m += n += d[i2];
+            n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);
+          }
+          a = n, b = m;
+        },
+        d: function() {
+          a %= 65521, b %= 65521;
+          return (a & 255) << 24 | (a & 65280) << 8 | (b & 255) << 8 | b >> 8;
+        }
+      };
+    };
+    var dopt = function(dat, opt, pre, post, st) {
+      if (!st) {
+        st = { l: 1 };
+        if (opt.dictionary) {
+          var dict = opt.dictionary.subarray(-32768);
+          var newDat = new u8(dict.length + dat.length);
+          newDat.set(dict);
+          newDat.set(dat, dict.length);
+          dat = newDat;
+          st.w = dict.length;
+        }
+      }
+      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+    };
+    var mrg = function(a, b) {
+      var o = {};
+      for (var k in a)
+        o[k] = a[k];
+      for (var k in b)
+        o[k] = b[k];
+      return o;
+    };
+    var wcln = function(fn, fnStr, td2) {
+      var dt = fn();
+      var st = fn.toString();
+      var ks = st.slice(st.indexOf("[") + 1, st.lastIndexOf("]")).replace(/\s+/g, "").split(",");
+      for (var i2 = 0; i2 < dt.length; ++i2) {
+        var v = dt[i2], k = ks[i2];
+        if (typeof v == "function") {
+          fnStr += ";" + k + "=";
+          var st_1 = v.toString();
+          if (v.prototype) {
+            if (st_1.indexOf("[native code]") != -1) {
+              var spInd = st_1.indexOf(" ", 8) + 1;
+              fnStr += st_1.slice(spInd, st_1.indexOf("(", spInd));
+            } else {
+              fnStr += st_1;
+              for (var t in v.prototype)
+                fnStr += ";" + k + ".prototype." + t + "=" + v.prototype[t].toString();
+            }
+          } else
+            fnStr += st_1;
+        } else
+          td2[k] = v;
+      }
+      return fnStr;
+    };
+    var ch = [];
+    var cbfs = function(v) {
+      var tl = [];
+      for (var k in v) {
+        if (v[k].buffer) {
+          tl.push((v[k] = new v[k].constructor(v[k])).buffer);
+        }
+      }
+      return tl;
+    };
+    var wrkr = function(fns, init, id, cb) {
+      if (!ch[id]) {
+        var fnStr = "", td_1 = {}, m = fns.length - 1;
+        for (var i2 = 0; i2 < m; ++i2)
+          fnStr = wcln(fns[i2], fnStr, td_1);
+        ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
+      }
+      var td2 = mrg({}, ch[id].e);
+      return (0, node_worker_1.default)(ch[id].c + ";onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=" + init.toString() + "}", id, td2, cbfs(td2), cb);
+    };
+    var bInflt = function() {
+      return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt];
+    };
+    var bDflt = function() {
+      return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf];
+    };
+    var gze = function() {
+      return [gzh, gzhl, wbytes, crc, crct];
+    };
+    var guze = function() {
+      return [gzs, gzl];
+    };
+    var zle = function() {
+      return [zlh, wbytes, adler];
+    };
+    var zule = function() {
+      return [zls];
+    };
+    var pbf = function(msg) {
+      return postMessage(msg, [msg.buffer]);
+    };
+    var gopt = function(o) {
+      return o && {
+        out: o.size && new u8(o.size),
+        dictionary: o.dictionary
+      };
+    };
+    var cbify = function(dat, opts, fns, init, id, cb) {
+      var w = wrkr(fns, init, id, function(err2, dat2) {
+        w.terminate();
+        cb(err2, dat2);
+      });
+      w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);
+      return function() {
+        w.terminate();
+      };
+    };
+    var astrm = function(strm) {
+      strm.ondata = function(dat, final) {
+        return postMessage([dat, final], [dat.buffer]);
+      };
+      return function(ev) {
+        if (ev.data[0]) {
+          strm.push(ev.data[0], ev.data[1]);
+          postMessage([ev.data[0].length]);
+        } else
+          strm.flush(ev.data[1]);
+      };
+    };
+    var astrmify = function(fns, strm, opts, init, id, flush, ext) {
+      var t;
+      var w = wrkr(fns, init, id, function(err2, dat) {
+        if (err2)
+          w.terminate(), strm.ondata.call(strm, err2);
+        else if (!Array.isArray(dat))
+          ext(dat);
+        else if (dat.length == 1) {
+          strm.queuedSize -= dat[0];
+          if (strm.ondrain)
+            strm.ondrain(dat[0]);
+        } else {
+          if (dat[1])
+            w.terminate();
+          strm.ondata.call(strm, err2, dat[0], dat[1]);
+        }
+      });
+      w.postMessage(opts);
+      strm.queuedSize = 0;
+      strm.push = function(d, f) {
+        if (!strm.ondata)
+          err(5);
+        if (t)
+          strm.ondata(err(4, 0, 1), null, !!f);
+        strm.queuedSize += d.length;
+        w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []);
+      };
+      strm.terminate = function() {
+        w.terminate();
+      };
+      if (flush) {
+        strm.flush = function(sync) {
+          w.postMessage([0, sync]);
+        };
+      }
+    };
+    var b2 = function(d, b) {
+      return d[b] | d[b + 1] << 8;
+    };
+    var b4 = function(d, b) {
+      return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    var b8 = function(d, b) {
+      return b4(d, b) + b4(d, b + 4) * 4294967296;
+    };
+    var wbytes = function(d, b, v) {
+      for (; v; ++b)
+        d[b] = v, v >>>= 8;
+    };
+    var gzh = function(c, o) {
+      var fn = o.filename;
+      c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3;
+      if (o.mtime != 0)
+        wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1e3));
+      if (fn) {
+        c[3] = 8;
+        for (var i2 = 0; i2 <= fn.length; ++i2)
+          c[i2 + 10] = fn.charCodeAt(i2);
+      }
+    };
+    var gzs = function(d) {
+      if (d[0] != 31 || d[1] != 139 || d[2] != 8)
+        err(6, "invalid gzip data");
+      var flg = d[3];
+      var st = 10;
+      if (flg & 4)
+        st += (d[10] | d[11] << 8) + 2;
+      for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
+        ;
+      return st + (flg & 2);
+    };
+    var gzl = function(d) {
+      var l = d.length;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
+    };
+    var gzhl = function(o) {
+      return 10 + (o.filename ? o.filename.length + 1 : 0);
+    };
+    var zlh = function(c, o) {
+      var lv = o.level, fl2 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+      c[0] = 120, c[1] = fl2 << 6 | (o.dictionary && 32);
+      c[1] |= 31 - (c[0] << 8 | c[1]) % 31;
+      if (o.dictionary) {
+        var h = adler();
+        h.p(o.dictionary);
+        wbytes(c, 2, h.d());
+      }
+    };
+    var zls = function(d, dict) {
+      if ((d[0] & 15) != 8 || d[0] >> 4 > 7 || (d[0] << 8 | d[1]) % 31)
+        err(6, "invalid zlib data");
+      if ((d[1] >> 5 & 1) == +!dict)
+        err(6, "invalid zlib data: " + (d[1] & 32 ? "need" : "unexpected") + " dictionary");
+      return (d[1] >> 3 & 4) + 2;
+    };
+    function StrmOpt(opts, cb) {
+      if (typeof opts == "function")
+        cb = opts, opts = {};
+      this.ondata = cb;
+      return opts;
+    }
+    var Deflate = /* @__PURE__ */ (function() {
+      function Deflate2(opts, cb) {
+        if (typeof opts == "function")
+          cb = opts, opts = {};
+        this.ondata = cb;
+        this.o = opts || {};
+        this.s = { l: 0, i: 32768, w: 32768, z: 32768 };
+        this.b = new u8(98304);
+        if (this.o.dictionary) {
+          var dict = this.o.dictionary.subarray(-32768);
+          this.b.set(dict, 32768 - dict.length);
+          this.s.i = 32768 - dict.length;
+        }
+      }
+      Deflate2.prototype.p = function(c, f) {
+        this.ondata(dopt(c, this.o, 0, 0, this.s), f);
+      };
+      Deflate2.prototype.push = function(chunk, final) {
+        if (!this.ondata)
+          err(5);
+        if (this.s.l)
+          err(4);
+        var endLen = chunk.length + this.s.z;
+        if (endLen > this.b.length) {
+          if (endLen > 2 * this.b.length - 32768) {
+            var newBuf = new u8(endLen & -32768);
+            newBuf.set(this.b.subarray(0, this.s.z));
+            this.b = newBuf;
+          }
+          var split = this.b.length - this.s.z;
+          this.b.set(chunk.subarray(0, split), this.s.z);
+          this.s.z = this.b.length;
+          this.p(this.b, false);
+          this.b.set(this.b.subarray(-32768));
+          this.b.set(chunk.subarray(split), 32768);
+          this.s.z = chunk.length - split + 32768;
+          this.s.i = 32766, this.s.w = 32768;
+        } else {
+          this.b.set(chunk, this.s.z);
+          this.s.z += chunk.length;
+        }
+        this.s.l = final & 1;
+        if (this.s.z > this.s.w + 8191 || final) {
+          this.p(this.b, final || false);
+          this.s.w = this.s.i, this.s.i -= 2;
+        }
+        if (final) {
+          this.s = this.o = {};
+          this.b = et;
+        }
+      };
+      Deflate2.prototype.flush = function(sync) {
+        if (!this.ondata)
+          err(5);
+        if (this.s.l)
+          err(4);
+        this.p(this.b, false);
+        this.s.w = this.s.i, this.s.i -= 2;
+        if (sync) {
+          var c = new u8(6);
+          c[0] = this.s.r >> 3;
+          var ep = wfblk(c, this.s.r, et);
+          this.s.r = 0;
+          this.ondata(c.subarray(0, ep >> 3), false);
+        }
+      };
+      return Deflate2;
+    })();
+    exports2.Deflate = Deflate;
+    var AsyncDeflate = /* @__PURE__ */ (function() {
+      function AsyncDeflate2(opts, cb) {
+        astrmify([
+          bDflt,
+          function() {
+            return [astrm, Deflate];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Deflate(ev.data);
+          onmessage = astrm(strm);
+        }, 6, 1);
+      }
+      return AsyncDeflate2;
+    })();
+    exports2.AsyncDeflate = AsyncDeflate;
+    function deflate(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bDflt
+      ], function(ev) {
+        return pbf(deflateSync(ev.data[0], ev.data[1]));
+      }, 0, cb);
+    }
+    function deflateSync(data, opts) {
+      return dopt(data, opts || {}, 0, 0);
+    }
+    var Inflate = /* @__PURE__ */ (function() {
+      function Inflate2(opts, cb) {
+        if (typeof opts == "function")
+          cb = opts, opts = {};
+        this.ondata = cb;
+        var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+        this.s = { i: 0, b: dict ? dict.length : 0 };
+        this.o = new u8(32768);
+        this.p = new u8(0);
+        if (dict)
+          this.o.set(dict);
+      }
+      Inflate2.prototype.e = function(c) {
+        if (!this.ondata)
+          err(5);
+        if (this.d)
+          err(4);
+        if (!this.p.length)
+          this.p = c;
+        else if (c.length) {
+          var n = new u8(this.p.length + c.length);
+          n.set(this.p), n.set(c, this.p.length), this.p = n;
+        }
+      };
+      Inflate2.prototype.c = function(final) {
+        this.s.i = +(this.d = final || false);
+        var bts = this.s.b;
+        var dt = inflt(this.p, this.s, this.o);
+        this.ondata(slc(dt, bts, this.s.b), this.d);
+        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+        this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+      };
+      Inflate2.prototype.push = function(chunk, final) {
+        this.e(chunk), this.c(final);
+      };
+      return Inflate2;
+    })();
+    exports2.Inflate = Inflate;
+    var AsyncInflate = /* @__PURE__ */ (function() {
+      function AsyncInflate2(opts, cb) {
+        astrmify([
+          bInflt,
+          function() {
+            return [astrm, Inflate];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Inflate(ev.data);
+          onmessage = astrm(strm);
+        }, 7, 0);
+      }
+      return AsyncInflate2;
+    })();
+    exports2.AsyncInflate = AsyncInflate;
+    function inflate(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bInflt
+      ], function(ev) {
+        return pbf(inflateSync(ev.data[0], gopt(ev.data[1])));
+      }, 1, cb);
+    }
+    function inflateSync(data, opts) {
+      return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
+    }
+    var Gzip = /* @__PURE__ */ (function() {
+      function Gzip2(opts, cb) {
+        this.c = crc();
+        this.l = 0;
+        this.v = 1;
+        Deflate.call(this, opts, cb);
+      }
+      Gzip2.prototype.push = function(chunk, final) {
+        this.c.p(chunk);
+        this.l += chunk.length;
+        Deflate.prototype.push.call(this, chunk, final);
+      };
+      Gzip2.prototype.p = function(c, f) {
+        var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s);
+        if (this.v)
+          gzh(raw, this.o), this.v = 0;
+        if (f)
+          wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);
+        this.ondata(raw, f);
+      };
+      Gzip2.prototype.flush = function(sync) {
+        Deflate.prototype.flush.call(this, sync);
+      };
+      return Gzip2;
+    })();
+    exports2.Gzip = Gzip;
+    exports2.Compress = Gzip;
+    var AsyncGzip = /* @__PURE__ */ (function() {
+      function AsyncGzip2(opts, cb) {
+        astrmify([
+          bDflt,
+          gze,
+          function() {
+            return [astrm, Deflate, Gzip];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Gzip(ev.data);
+          onmessage = astrm(strm);
+        }, 8, 1);
+      }
+      return AsyncGzip2;
+    })();
+    exports2.AsyncGzip = AsyncGzip;
+    exports2.AsyncCompress = AsyncGzip;
+    function gzip(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bDflt,
+        gze,
+        function() {
+          return [gzipSync];
+        }
+      ], function(ev) {
+        return pbf(gzipSync(ev.data[0], ev.data[1]));
+      }, 2, cb);
+    }
+    function gzipSync(data, opts) {
+      if (!opts)
+        opts = {};
+      var c = crc(), l = data.length;
+      c.p(data);
+      var d = dopt(data, opts, gzhl(opts), 8), s = d.length;
+      return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
+    }
+    var Gunzip = /* @__PURE__ */ (function() {
+      function Gunzip2(opts, cb) {
+        this.v = 1;
+        this.r = 0;
+        Inflate.call(this, opts, cb);
+      }
+      Gunzip2.prototype.push = function(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        this.r += chunk.length;
+        if (this.v) {
+          var p = this.p.subarray(this.v - 1);
+          var s = p.length > 3 ? gzs(p) : 4;
+          if (s > p.length) {
+            if (!final)
+              return;
+          } else if (this.v > 1 && this.onmember) {
+            this.onmember(this.r - p.length);
+          }
+          this.p = p.subarray(s), this.v = 0;
+        }
+        Inflate.prototype.c.call(this, 0);
+        if (this.s.f && !this.s.l) {
+          this.v = shft(this.s.p) + 9;
+          this.s = { i: 0 };
+          this.o = new u8(0);
+          this.push(new u8(0), final);
+        } else if (final) {
+          Inflate.prototype.c.call(this, final);
+        }
+      };
+      return Gunzip2;
+    })();
+    exports2.Gunzip = Gunzip;
+    var AsyncGunzip = /* @__PURE__ */ (function() {
+      function AsyncGunzip2(opts, cb) {
+        var _this = this;
+        astrmify([
+          bInflt,
+          guze,
+          function() {
+            return [astrm, Inflate, Gunzip];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Gunzip(ev.data);
+          strm.onmember = function(offset) {
+            return postMessage(offset);
+          };
+          onmessage = astrm(strm);
+        }, 9, 0, function(offset) {
+          return _this.onmember && _this.onmember(offset);
+        });
+      }
+      return AsyncGunzip2;
+    })();
+    exports2.AsyncGunzip = AsyncGunzip;
+    function gunzip(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bInflt,
+        guze,
+        function() {
+          return [gunzipSync];
+        }
+      ], function(ev) {
+        return pbf(gunzipSync(ev.data[0], ev.data[1]));
+      }, 3, cb);
+    }
+    function gunzipSync(data, opts) {
+      var st = gzs(data);
+      if (st + 8 > data.length)
+        err(6, "invalid gzip data");
+      return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
+    }
+    var Zlib = /* @__PURE__ */ (function() {
+      function Zlib2(opts, cb) {
+        this.c = adler();
+        this.v = 1;
+        Deflate.call(this, opts, cb);
+      }
+      Zlib2.prototype.push = function(chunk, final) {
+        this.c.p(chunk);
+        Deflate.prototype.push.call(this, chunk, final);
+      };
+      Zlib2.prototype.p = function(c, f) {
+        var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s);
+        if (this.v)
+          zlh(raw, this.o), this.v = 0;
+        if (f)
+          wbytes(raw, raw.length - 4, this.c.d());
+        this.ondata(raw, f);
+      };
+      Zlib2.prototype.flush = function(sync) {
+        Deflate.prototype.flush.call(this, sync);
+      };
+      return Zlib2;
+    })();
+    exports2.Zlib = Zlib;
+    var AsyncZlib = /* @__PURE__ */ (function() {
+      function AsyncZlib2(opts, cb) {
+        astrmify([
+          bDflt,
+          zle,
+          function() {
+            return [astrm, Deflate, Zlib];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Zlib(ev.data);
+          onmessage = astrm(strm);
+        }, 10, 1);
+      }
+      return AsyncZlib2;
+    })();
+    exports2.AsyncZlib = AsyncZlib;
+    function zlib(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bDflt,
+        zle,
+        function() {
+          return [zlibSync];
+        }
+      ], function(ev) {
+        return pbf(zlibSync(ev.data[0], ev.data[1]));
+      }, 4, cb);
+    }
+    function zlibSync(data, opts) {
+      if (!opts)
+        opts = {};
+      var a = adler();
+      a.p(data);
+      var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);
+      return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
+    }
+    var Unzlib = /* @__PURE__ */ (function() {
+      function Unzlib2(opts, cb) {
+        Inflate.call(this, opts, cb);
+        this.v = opts && opts.dictionary ? 2 : 1;
+      }
+      Unzlib2.prototype.push = function(chunk, final) {
+        Inflate.prototype.e.call(this, chunk);
+        if (this.v) {
+          if (this.p.length < 6 && !final)
+            return;
+          this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;
+        }
+        if (final) {
+          if (this.p.length < 4)
+            err(6, "invalid zlib data");
+          this.p = this.p.subarray(0, -4);
+        }
+        Inflate.prototype.c.call(this, final);
+      };
+      return Unzlib2;
+    })();
+    exports2.Unzlib = Unzlib;
+    var AsyncUnzlib = /* @__PURE__ */ (function() {
+      function AsyncUnzlib2(opts, cb) {
+        astrmify([
+          bInflt,
+          zule,
+          function() {
+            return [astrm, Inflate, Unzlib];
+          }
+        ], this, StrmOpt.call(this, opts, cb), function(ev) {
+          var strm = new Unzlib(ev.data);
+          onmessage = astrm(strm);
+        }, 11, 0);
+      }
+      return AsyncUnzlib2;
+    })();
+    exports2.AsyncUnzlib = AsyncUnzlib;
+    function unzlib(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return cbify(data, opts, [
+        bInflt,
+        zule,
+        function() {
+          return [unzlibSync];
+        }
+      ], function(ev) {
+        return pbf(unzlibSync(ev.data[0], gopt(ev.data[1])));
+      }, 5, cb);
+    }
+    function unzlibSync(data, opts) {
+      return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
+    }
+    var Decompress = /* @__PURE__ */ (function() {
+      function Decompress2(opts, cb) {
+        this.o = StrmOpt.call(this, opts, cb) || {};
+        this.G = Gunzip;
+        this.I = Inflate;
+        this.Z = Unzlib;
+      }
+      Decompress2.prototype.i = function() {
+        var _this = this;
+        this.s.ondata = function(dat, final) {
+          _this.ondata(dat, final);
+        };
+      };
+      Decompress2.prototype.push = function(chunk, final) {
+        if (!this.ondata)
+          err(5);
+        if (!this.s) {
+          if (this.p && this.p.length) {
+            var n = new u8(this.p.length + chunk.length);
+            n.set(this.p), n.set(chunk, this.p.length);
+          } else
+            this.p = chunk;
+          if (this.p.length > 2) {
+            this.s = this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8 ? new this.G(this.o) : (this.p[0] & 15) != 8 || this.p[0] >> 4 > 7 || (this.p[0] << 8 | this.p[1]) % 31 ? new this.I(this.o) : new this.Z(this.o);
+            this.i();
+            this.s.push(this.p, final);
+            this.p = null;
+          }
+        } else
+          this.s.push(chunk, final);
+      };
+      return Decompress2;
+    })();
+    exports2.Decompress = Decompress;
+    var AsyncDecompress = /* @__PURE__ */ (function() {
+      function AsyncDecompress2(opts, cb) {
+        Decompress.call(this, opts, cb);
+        this.queuedSize = 0;
+        this.G = AsyncGunzip;
+        this.I = AsyncInflate;
+        this.Z = AsyncUnzlib;
+      }
+      AsyncDecompress2.prototype.i = function() {
+        var _this = this;
+        this.s.ondata = function(err2, dat, final) {
+          _this.ondata(err2, dat, final);
+        };
+        this.s.ondrain = function(size) {
+          _this.queuedSize -= size;
+          if (_this.ondrain)
+            _this.ondrain(size);
+        };
+      };
+      AsyncDecompress2.prototype.push = function(chunk, final) {
+        this.queuedSize += chunk.length;
+        Decompress.prototype.push.call(this, chunk, final);
+      };
+      return AsyncDecompress2;
+    })();
+    exports2.AsyncDecompress = AsyncDecompress;
+    function decompress(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzip(data, opts, cb) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflate(data, opts, cb) : unzlib(data, opts, cb);
+    }
+    function decompressSync(data, opts) {
+      return data[0] == 31 && data[1] == 139 && data[2] == 8 ? gunzipSync(data, opts) : (data[0] & 15) != 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 ? inflateSync(data, opts) : unzlibSync(data, opts);
+    }
+    var fltn = function(d, p, t, o) {
+      for (var k in d) {
+        var val = d[k], n = p + k, op = o;
+        if (Array.isArray(val))
+          op = mrg(o, val[1]), val = val[0];
+        if (ArrayBuffer.isView(val))
+          t[n] = [val, op];
+        else {
+          t[n += "/"] = [new u8(0), op];
+          fltn(val, n, t, o);
+        }
+      }
+    };
+    var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+    var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+    var tds = 0;
+    try {
+      td.decode(et, { stream: true });
+      tds = 1;
+    } catch (e) {
+    }
+    var dutf8 = function(d) {
+      for (var r = "", i2 = 0; ; ) {
+        var c = d[i2++];
+        var eb = (c > 127) + (c > 223) + (c > 239);
+        if (i2 + eb > d.length)
+          return { s: r, r: slc(d, i2 - 1) };
+        if (!eb)
+          r += String.fromCharCode(c);
+        else if (eb == 3) {
+          c = ((c & 15) << 18 | (d[i2++] & 63) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63) - 65536, r += String.fromCharCode(55296 | c >> 10, 56320 | c & 1023);
+        } else if (eb & 1)
+          r += String.fromCharCode((c & 31) << 6 | d[i2++] & 63);
+        else
+          r += String.fromCharCode((c & 15) << 12 | (d[i2++] & 63) << 6 | d[i2++] & 63);
+      }
+    };
+    var DecodeUTF8 = /* @__PURE__ */ (function() {
+      function DecodeUTF82(cb) {
+        this.ondata = cb;
+        if (tds)
+          this.t = new TextDecoder();
+        else
+          this.p = et;
+      }
+      DecodeUTF82.prototype.push = function(chunk, final) {
+        if (!this.ondata)
+          err(5);
+        final = !!final;
+        if (this.t) {
+          this.ondata(this.t.decode(chunk, { stream: true }), final);
+          if (final) {
+            if (this.t.decode().length)
+              err(8);
+            this.t = null;
+          }
+          return;
+        }
+        if (!this.p)
+          err(4);
+        var dat = new u8(this.p.length + chunk.length);
+        dat.set(this.p);
+        dat.set(chunk, this.p.length);
+        var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+        if (final) {
+          if (r.length)
+            err(8);
+          this.p = null;
+        } else
+          this.p = r;
+        this.ondata(s, final);
+      };
+      return DecodeUTF82;
+    })();
+    exports2.DecodeUTF8 = DecodeUTF8;
+    var EncodeUTF8 = /* @__PURE__ */ (function() {
+      function EncodeUTF82(cb) {
+        this.ondata = cb;
+      }
+      EncodeUTF82.prototype.push = function(chunk, final) {
+        if (!this.ondata)
+          err(5);
+        if (this.d)
+          err(4);
+        this.ondata(strToU8(chunk), this.d = final || false);
+      };
+      return EncodeUTF82;
+    })();
+    exports2.EncodeUTF8 = EncodeUTF8;
+    function strToU8(str, latin1) {
+      if (latin1) {
+        var ar_1 = new u8(str.length);
+        for (var i2 = 0; i2 < str.length; ++i2)
+          ar_1[i2] = str.charCodeAt(i2);
+        return ar_1;
+      }
+      if (te)
+        return te.encode(str);
+      var l = str.length;
+      var ar = new u8(str.length + (str.length >> 1));
+      var ai = 0;
+      var w = function(v) {
+        ar[ai++] = v;
+      };
+      for (var i2 = 0; i2 < l; ++i2) {
+        if (ai + 5 > ar.length) {
+          var n = new u8(ai + 8 + (l - i2 << 1));
+          n.set(ar);
+          ar = n;
+        }
+        var c = str.charCodeAt(i2);
+        if (c < 128 || latin1)
+          w(c);
+        else if (c < 2048)
+          w(192 | c >> 6), w(128 | c & 63);
+        else if (c > 55295 && c < 57344)
+          c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i2) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+        else
+          w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+      }
+      return slc(ar, 0, ai);
+    }
+    function strFromU8(dat, latin1) {
+      if (latin1) {
+        var r = "";
+        for (var i2 = 0; i2 < dat.length; i2 += 16384)
+          r += String.fromCharCode.apply(null, dat.subarray(i2, i2 + 16384));
+        return r;
+      } else if (td) {
+        return td.decode(dat);
+      } else {
+        var _a2 = dutf8(dat), s = _a2.s, r = _a2.r;
+        if (r.length)
+          err(8);
+        return s;
+      }
+    }
+    var dbf = function(l) {
+      return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0;
+    };
+    var slzh = function(d, b) {
+      return b + 30 + b2(d, b + 26) + b2(d, b + 28);
+    };
+    var zh = function(d, b, z9) {
+      var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
+      var _a2 = z64hs(d, es, efl, z9, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+      return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
+    };
+    var z64hs = function(d, b, l, z9, sc, su, off) {
+      var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
+      var nf = nsc + nsu + noff;
+      if (z9 && nf) {
+        for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
+          if (b2(d, b) == 1) {
+            return [
+              nsc ? b8(d, b + 4 + 8 * nsu) : sc,
+              nsu ? b8(d, b + 4) : su,
+              noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
+              1
+            ];
+          }
+        }
+        if (z9 < 2)
+          err(13);
+      }
+      return [sc, su, off, 0];
+    };
+    var exfl = function(ex) {
+      var le = 0;
+      if (ex) {
+        for (var k in ex) {
+          var l = ex[k].length;
+          if (l > 65535)
+            err(9);
+          le += l + 4;
+        }
+      }
+      return le;
+    };
+    var wzh = function(d, b, f, fn, u, c, ce, co) {
+      var fl2 = fn.length, ex = f.extra, col = co && co.length;
+      var exl = exfl(ex);
+      wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+      if (ce != null)
+        d[b++] = 20, d[b++] = f.os;
+      d[b] = 20, b += 2;
+      d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+      d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+      var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+      if (y < 0 || y > 119)
+        err(10);
+      wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+      if (c != -1) {
+        wbytes(d, b, f.crc);
+        wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+        wbytes(d, b + 8, f.size);
+      }
+      wbytes(d, b + 12, fl2);
+      wbytes(d, b + 14, exl), b += 16;
+      if (ce != null) {
+        wbytes(d, b, col);
+        wbytes(d, b + 6, f.attrs);
+        wbytes(d, b + 10, ce), b += 14;
+      }
+      d.set(fn, b);
+      b += fl2;
+      if (exl) {
+        for (var k in ex) {
+          var exf = ex[k], l = exf.length;
+          wbytes(d, b, +k);
+          wbytes(d, b + 2, l);
+          d.set(exf, b + 4), b += 4 + l;
+        }
+      }
+      if (col)
+        d.set(co, b), b += col;
+      return b;
+    };
+    var wzf = function(o, b, c, d, e) {
+      wbytes(o, b, 101010256);
+      wbytes(o, b + 8, c);
+      wbytes(o, b + 10, c);
+      wbytes(o, b + 12, d);
+      wbytes(o, b + 16, e);
+    };
+    var ZipPassThrough = /* @__PURE__ */ (function() {
+      function ZipPassThrough2(filename) {
+        this.filename = filename;
+        this.c = crc();
+        this.size = 0;
+        this.compression = 0;
+      }
+      ZipPassThrough2.prototype.process = function(chunk, final) {
+        this.ondata(null, chunk, final);
+      };
+      ZipPassThrough2.prototype.push = function(chunk, final) {
+        if (!this.ondata)
+          err(5);
+        this.c.p(chunk);
+        this.size += chunk.length;
+        if (final)
+          this.crc = this.c.d();
+        this.process(chunk, final || false);
+      };
+      return ZipPassThrough2;
+    })();
+    exports2.ZipPassThrough = ZipPassThrough;
+    var ZipDeflate = /* @__PURE__ */ (function() {
+      function ZipDeflate2(filename, opts) {
+        var _this = this;
+        if (!opts)
+          opts = {};
+        ZipPassThrough.call(this, filename);
+        this.d = new Deflate(opts, function(dat, final) {
+          _this.ondata(null, dat, final);
+        });
+        this.compression = 8;
+        this.flag = dbf(opts.level);
+      }
+      ZipDeflate2.prototype.process = function(chunk, final) {
+        try {
+          this.d.push(chunk, final);
+        } catch (e) {
+          this.ondata(e, null, final);
+        }
+      };
+      ZipDeflate2.prototype.push = function(chunk, final) {
+        ZipPassThrough.prototype.push.call(this, chunk, final);
+      };
+      return ZipDeflate2;
+    })();
+    exports2.ZipDeflate = ZipDeflate;
+    var AsyncZipDeflate = /* @__PURE__ */ (function() {
+      function AsyncZipDeflate2(filename, opts) {
+        var _this = this;
+        if (!opts)
+          opts = {};
+        ZipPassThrough.call(this, filename);
+        this.d = new AsyncDeflate(opts, function(err2, dat, final) {
+          _this.ondata(err2, dat, final);
+        });
+        this.compression = 8;
+        this.flag = dbf(opts.level);
+        this.terminate = this.d.terminate;
+      }
+      AsyncZipDeflate2.prototype.process = function(chunk, final) {
+        this.d.push(chunk, final);
+      };
+      AsyncZipDeflate2.prototype.push = function(chunk, final) {
+        ZipPassThrough.prototype.push.call(this, chunk, final);
+      };
+      return AsyncZipDeflate2;
+    })();
+    exports2.AsyncZipDeflate = AsyncZipDeflate;
+    var Zip = /* @__PURE__ */ (function() {
+      function Zip2(cb) {
+        this.ondata = cb;
+        this.u = [];
+        this.d = 1;
+      }
+      Zip2.prototype.add = function(file) {
+        var _this = this;
+        if (!this.ondata)
+          err(5);
+        if (this.d & 2)
+          this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);
+        else {
+          var f = strToU8(file.filename), fl_1 = f.length;
+          var com = file.comment, o = com && strToU8(com);
+          var u = fl_1 != file.filename.length || o && com.length != o.length;
+          var hl_1 = fl_1 + exfl(file.extra) + 30;
+          if (fl_1 > 65535)
+            this.ondata(err(11, 0, 1), null, false);
+          var header = new u8(hl_1);
+          wzh(header, 0, file, f, u, -1);
+          var chks_1 = [header];
+          var pAll_1 = function() {
+            for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {
+              var chk = chks_2[_i];
+              _this.ondata(null, chk, false);
+            }
+            chks_1 = [];
+          };
+          var tr_1 = this.d;
+          this.d = 0;
+          var ind_1 = this.u.length;
+          var uf_1 = mrg(file, {
+            f,
+            u,
+            o,
+            t: function() {
+              if (file.terminate)
+                file.terminate();
+            },
+            r: function() {
+              pAll_1();
+              if (tr_1) {
+                var nxt = _this.u[ind_1 + 1];
+                if (nxt)
+                  nxt.r();
+                else
+                  _this.d = 1;
+              }
+              tr_1 = 1;
+            }
+          });
+          var cl_1 = 0;
+          file.ondata = function(err2, dat, final) {
+            if (err2) {
+              _this.ondata(err2, dat, final);
+              _this.terminate();
+            } else {
+              cl_1 += dat.length;
+              chks_1.push(dat);
+              if (final) {
+                var dd = new u8(16);
+                wbytes(dd, 0, 134695760);
+                wbytes(dd, 4, file.crc);
+                wbytes(dd, 8, cl_1);
+                wbytes(dd, 12, file.size);
+                chks_1.push(dd);
+                uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;
+                if (tr_1)
+                  uf_1.r();
+                tr_1 = 1;
+              } else if (tr_1)
+                pAll_1();
+            }
+          };
+          this.u.push(uf_1);
+        }
+      };
+      Zip2.prototype.end = function() {
+        var _this = this;
+        if (this.d & 2) {
+          this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);
+          return;
+        }
+        if (this.d)
+          this.e();
+        else
+          this.u.push({
+            r: function() {
+              if (!(_this.d & 1))
+                return;
+              _this.u.splice(-1, 1);
+              _this.e();
+            },
+            t: function() {
+            }
+          });
+        this.d = 3;
+      };
+      Zip2.prototype.e = function() {
+        var bt = 0, l = 0, tl = 0;
+        for (var _i = 0, _a2 = this.u; _i < _a2.length; _i++) {
+          var f = _a2[_i];
+          tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);
+        }
+        var out = new u8(tl + 22);
+        for (var _b2 = 0, _c = this.u; _b2 < _c.length; _b2++) {
+          var f = _c[_b2];
+          wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o);
+          bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;
+        }
+        wzf(out, bt, this.u.length, tl, l);
+        this.ondata(null, out, true);
+        this.d = 2;
+      };
+      Zip2.prototype.terminate = function() {
+        for (var _i = 0, _a2 = this.u; _i < _a2.length; _i++) {
+          var f = _a2[_i];
+          f.t();
+        }
+        this.d = 2;
+      };
+      return Zip2;
+    })();
+    exports2.Zip = Zip;
+    function zip(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      var r = {};
+      fltn(data, "", r, opts);
+      var k = Object.keys(r);
+      var lft = k.length, o = 0, tot = 0;
+      var slft = lft, files = new Array(lft);
+      var term = [];
+      var tAll = function() {
+        for (var i3 = 0; i3 < term.length; ++i3)
+          term[i3]();
+      };
+      var cbd = function(a, b) {
+        mt(function() {
+          cb(a, b);
+        });
+      };
+      mt(function() {
+        cbd = cb;
+      });
+      var cbf = function() {
+        var out = new u8(tot + 22), oe = o, cdl = tot - o;
+        tot = 0;
+        for (var i3 = 0; i3 < slft; ++i3) {
+          var f = files[i3];
+          try {
+            var l = f.c.length;
+            wzh(out, tot, f, f.f, f.u, l);
+            var badd = 30 + f.f.length + exfl(f.extra);
+            var loc = tot + badd;
+            out.set(f.c, loc);
+            wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;
+          } catch (e) {
+            return cbd(e, null);
+          }
+        }
+        wzf(out, o, files.length, cdl, oe);
+        cbd(null, out);
+      };
+      if (!lft)
+        cbf();
+      var _loop_1 = function(i3) {
+        var fn = k[i3];
+        var _a2 = r[fn], file = _a2[0], p = _a2[1];
+        var c = crc(), size = file.length;
+        c.p(file);
+        var f = strToU8(fn), s = f.length;
+        var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+        var exl = exfl(p.extra);
+        var compression = p.level == 0 ? 0 : 8;
+        var cbl = function(e, d) {
+          if (e) {
+            tAll();
+            cbd(e, null);
+          } else {
+            var l = d.length;
+            files[i3] = mrg(p, {
+              size,
+              crc: c.d(),
+              c: d,
+              f,
+              m,
+              u: s != fn.length || m && com.length != ms,
+              compression
+            });
+            o += 30 + s + exl + l;
+            tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+            if (!--lft)
+              cbf();
+          }
+        };
+        if (s > 65535)
+          cbl(err(11, 0, 1), null);
+        if (!compression)
+          cbl(null, file);
+        else if (size < 16e4) {
+          try {
+            cbl(null, deflateSync(file, p));
+          } catch (e) {
+            cbl(e, null);
+          }
+        } else
+          term.push(deflate(file, p, cbl));
+      };
+      for (var i2 = 0; i2 < slft; ++i2) {
+        _loop_1(i2);
+      }
+      return tAll;
+    }
+    function zipSync(data, opts) {
+      if (!opts)
+        opts = {};
+      var r = {};
+      var files = [];
+      fltn(data, "", r, opts);
+      var o = 0;
+      var tot = 0;
+      for (var fn in r) {
+        var _a2 = r[fn], file = _a2[0], p = _a2[1];
+        var compression = p.level == 0 ? 0 : 8;
+        var f = strToU8(fn), s = f.length;
+        var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+        var exl = exfl(p.extra);
+        if (s > 65535)
+          err(11);
+        var d = compression ? deflateSync(file, p) : file, l = d.length;
+        var c = crc();
+        c.p(file);
+        files.push(mrg(p, {
+          size: file.length,
+          crc: c.d(),
+          c: d,
+          f,
+          m,
+          u: s != fn.length || m && com.length != ms,
+          o,
+          compression
+        }));
+        o += 30 + s + exl + l;
+        tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+      }
+      var out = new u8(tot + 22), oe = o, cdl = tot - o;
+      for (var i2 = 0; i2 < files.length; ++i2) {
+        var f = files[i2];
+        wzh(out, f.o, f, f.f, f.u, f.c.length);
+        var badd = 30 + f.f.length + exfl(f.extra);
+        out.set(f.c, f.o + badd);
+        wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
+      }
+      wzf(out, o, files.length, cdl, oe);
+      return out;
+    }
+    var UnzipPassThrough = /* @__PURE__ */ (function() {
+      function UnzipPassThrough2() {
+      }
+      UnzipPassThrough2.prototype.push = function(chunk, final) {
+        this.ondata(null, chunk, final);
+      };
+      UnzipPassThrough2.compression = 0;
+      return UnzipPassThrough2;
+    })();
+    exports2.UnzipPassThrough = UnzipPassThrough;
+    var UnzipInflate = /* @__PURE__ */ (function() {
+      function UnzipInflate2() {
+        var _this = this;
+        this.i = new Inflate(function(dat, final) {
+          _this.ondata(null, dat, final);
+        });
+      }
+      UnzipInflate2.prototype.push = function(chunk, final) {
+        try {
+          this.i.push(chunk, final);
+        } catch (e) {
+          this.ondata(e, null, final);
+        }
+      };
+      UnzipInflate2.compression = 8;
+      return UnzipInflate2;
+    })();
+    exports2.UnzipInflate = UnzipInflate;
+    var AsyncUnzipInflate = /* @__PURE__ */ (function() {
+      function AsyncUnzipInflate2(_, sz) {
+        var _this = this;
+        if (sz < 32e4) {
+          this.i = new Inflate(function(dat, final) {
+            _this.ondata(null, dat, final);
+          });
+        } else {
+          this.i = new AsyncInflate(function(err2, dat, final) {
+            _this.ondata(err2, dat, final);
+          });
+          this.terminate = this.i.terminate;
+        }
+      }
+      AsyncUnzipInflate2.prototype.push = function(chunk, final) {
+        if (this.i.terminate)
+          chunk = slc(chunk, 0);
+        this.i.push(chunk, final);
+      };
+      AsyncUnzipInflate2.compression = 8;
+      return AsyncUnzipInflate2;
+    })();
+    exports2.AsyncUnzipInflate = AsyncUnzipInflate;
+    var Unzip = /* @__PURE__ */ (function() {
+      function Unzip2(cb) {
+        this.onfile = cb;
+        this.k = [];
+        this.o = {
+          0: UnzipPassThrough
+        };
+        this.p = et;
+      }
+      Unzip2.prototype.push = function(chunk, final) {
+        var _this = this;
+        if (!this.onfile)
+          err(5);
+        if (!this.p)
+          err(4);
+        if (this.c > 0) {
+          var len = Math.min(this.c, chunk.length);
+          var toAdd = chunk.subarray(0, len);
+          this.c -= len;
+          if (this.d)
+            this.d.push(toAdd, !this.c);
+          else
+            this.k[0].push(toAdd);
+          chunk = chunk.subarray(len);
+          if (chunk.length)
+            return this.push(chunk, final);
+        } else {
+          var f = 0, i2 = 0, is = void 0, buf = void 0;
+          if (!this.p.length)
+            buf = chunk;
+          else if (!chunk.length)
+            buf = this.p;
+          else {
+            buf = new u8(this.p.length + chunk.length);
+            buf.set(this.p), buf.set(chunk, this.p.length);
+          }
+          var l = buf.length, oc = this.c, add = oc && this.d;
+          var _loop_2 = function() {
+            var sig = b4(buf, i2);
+            if (sig == 67324752) {
+              f = 1, is = i2;
+              this_1.d = null;
+              this_1.c = 0;
+              var bf = b2(buf, i2 + 6), cmp_1 = b2(buf, i2 + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i2 + 26), es = b2(buf, i2 + 28);
+              if (l > i2 + 30 + fnl + es) {
+                var chks_3 = [];
+                this_1.k.unshift(chks_3);
+                f = 2;
+                var lsc = b4(buf, i2 + 18), lsu = b4(buf, i2 + 22);
+                var fn_1 = strFromU8(buf.subarray(i2 + 30, i2 += 30 + fnl), !u);
+                var _a2 = z64hs(buf, i2, es, 2, lsc, lsu, 0), sc_1 = _a2[0], su_1 = _a2[1], z64 = _a2[3];
+                if (dd)
+                  sc_1 = -1 - z64;
+                i2 += es;
+                this_1.c = sc_1;
+                var d_1;
+                var file_1 = {
+                  name: fn_1,
+                  compression: cmp_1,
+                  start: function() {
+                    if (!file_1.ondata)
+                      err(5);
+                    if (!sc_1)
+                      file_1.ondata(null, et, true);
+                    else {
+                      var ctr = _this.o[cmp_1];
+                      if (!ctr)
+                        file_1.ondata(err(14, "unknown compression type " + cmp_1, 1), null, false);
+                      d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
+                      d_1.ondata = function(err2, dat3, final2) {
+                        file_1.ondata(err2, dat3, final2);
+                      };
+                      for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
+                        var dat2 = chks_4[_i];
+                        d_1.push(dat2, false);
+                      }
+                      if (_this.k[0] == chks_3 && _this.c)
+                        _this.d = d_1;
+                      else
+                        d_1.push(et, true);
+                    }
+                  },
+                  terminate: function() {
+                    if (d_1 && d_1.terminate)
+                      d_1.terminate();
+                  }
+                };
+                if (sc_1 >= 0)
+                  file_1.size = sc_1, file_1.originalSize = su_1;
+                this_1.onfile(file_1);
+              }
+              return "break";
+            } else if (oc) {
+              if (sig == 134695760) {
+                is = i2 += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
+                return "break";
+              } else if (sig == 33639248) {
+                is = i2 -= 4, f = 3, this_1.c = 0;
+                return "break";
+              }
+            }
+          };
+          var this_1 = this;
+          for (; i2 < l - 4; ++i2) {
+            var state_1 = _loop_2();
+            if (state_1 === "break")
+              break;
+          }
+          this.p = et;
+          if (oc < 0) {
+            var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 134695760 && 4)) : buf.subarray(0, i2);
+            if (add)
+              add.push(dat, !!f);
+            else
+              this.k[+(f == 2)].push(dat);
+          }
+          if (f & 2)
+            return this.push(buf.subarray(i2), final);
+          this.p = buf.subarray(i2);
+        }
+        if (final) {
+          if (this.c)
+            err(13);
+          this.p = null;
+        }
+      };
+      Unzip2.prototype.register = function(decoder) {
+        this.o[decoder.compression] = decoder;
+      };
+      return Unzip2;
+    })();
+    exports2.Unzip = Unzip;
+    var mt = typeof queueMicrotask == "function" ? queueMicrotask : typeof setTimeout == "function" ? setTimeout : function(fn) {
+      fn();
+    };
+    function unzip(data, opts, cb) {
+      if (!cb)
+        cb = opts, opts = {};
+      if (typeof cb != "function")
+        err(7);
+      var term = [];
+      var tAll = function() {
+        for (var i3 = 0; i3 < term.length; ++i3)
+          term[i3]();
+      };
+      var files = {};
+      var cbd = function(a, b) {
+        mt(function() {
+          cb(a, b);
+        });
+      };
+      mt(function() {
+        cbd = cb;
+      });
+      var e = data.length - 22;
+      for (; b4(data, e) != 101010256; --e) {
+        if (!e || data.length - e > 65558) {
+          cbd(err(13, 0, 1), null);
+          return tAll;
+        }
+      }
+      ;
+      var lft = b2(data, e + 8);
+      if (lft) {
+        var c = lft;
+        var o = b4(data, e + 16);
+        var z9 = b4(data, e - 20) == 117853008;
+        if (z9) {
+          var ze = b4(data, e - 12);
+          z9 = b4(data, ze) == 101075792;
+          if (z9) {
+            c = lft = b4(data, ze + 32);
+            o = b4(data, ze + 48);
+          }
+        }
+        var fltr = opts && opts.filter;
+        var _loop_3 = function(i3) {
+          var _a2 = zh(data, o, z9), c_1 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+          o = no;
+          var cbl = function(e2, d) {
+            if (e2) {
+              tAll();
+              cbd(e2, null);
+            } else {
+              if (d)
+                files[fn] = d;
+              if (!--lft)
+                cbd(null, files);
+            }
+          };
+          if (!fltr || fltr({
+            name: fn,
+            size: sc,
+            originalSize: su,
+            compression: c_1
+          })) {
+            if (!c_1)
+              cbl(null, slc(data, b, b + sc));
+            else if (c_1 == 8) {
+              var infl = data.subarray(b, b + sc);
+              if (su < 524288 || sc > 0.8 * su) {
+                try {
+                  cbl(null, inflateSync(infl, { out: new u8(su) }));
+                } catch (e2) {
+                  cbl(e2, null);
+                }
+              } else
+                term.push(inflate(infl, { size: su }, cbl));
+            } else
+              cbl(err(14, "unknown compression type " + c_1, 1), null);
+          } else
+            cbl(null, null);
+        };
+        for (var i2 = 0; i2 < c; ++i2) {
+          _loop_3(i2);
+        }
+      } else
+        cbd(null, {});
+      return tAll;
+    }
+    function unzipSync(data, opts) {
+      var files = {};
+      var e = data.length - 22;
+      for (; b4(data, e) != 101010256; --e) {
+        if (!e || data.length - e > 65558)
+          err(13);
+      }
+      ;
+      var c = b2(data, e + 8);
+      if (!c)
+        return {};
+      var o = b4(data, e + 16);
+      var z9 = b4(data, e - 20) == 117853008;
+      if (z9) {
+        var ze = b4(data, e - 12);
+        z9 = b4(data, ze) == 101075792;
+        if (z9) {
+          c = b4(data, ze + 32);
+          o = b4(data, ze + 48);
+        }
+      }
+      var fltr = opts && opts.filter;
+      for (var i2 = 0; i2 < c; ++i2) {
+        var _a2 = zh(data, o, z9), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+        o = no;
+        if (!fltr || fltr({
+          name: fn,
+          size: sc,
+          originalSize: su,
+          compression: c_2
+        })) {
+          if (!c_2)
+            files[fn] = slc(data, b, b + sc);
+          else if (c_2 == 8)
+            files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
+          else
+            err(14, "unknown compression type " + c_2);
+        }
+      }
+      return files;
+    }
+  }
+});
+
+// sdk/dist/index.js
+var require_dist = __commonJS({
+  "sdk/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __commonJS2 = (cb, mod) => function __require() {
+      return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var require_package = __commonJS2({
+      "package.json"(exports22, module22) {
+        module22.exports = {
+          name: "@wairon/sdk",
+          version: "0.0.0-dev",
+          description: "Wairon pack-archive (.wpack) format authority and authoring toolkit \u2014 scaffold, build, inspect, and safely extract wairon extension packs.",
+          keywords: [
+            "wairon",
+            "sdd",
+            "pack",
+            "wpack",
+            "archive",
+            "developer-tools"
+          ],
+          author: "SYW",
+          license: "MIT",
+          homepage: "https://github.com/SYW-Apps/Waffle-AIron",
+          repository: {
+            type: "git",
+            url: "https://github.com/SYW-Apps/Waffle-AIron.git"
+          },
+          type: "commonjs",
+          main: "./dist/index.js",
+          types: "./dist/index.d.ts",
+          files: [
+            "dist",
+            "README.md"
+          ],
+          engines: {
+            node: ">=18.0.0"
+          },
+          scripts: {
+            build: "tsup",
+            typecheck: "tsc --noEmit",
+            test: "vitest run",
+            "test:watch": "vitest",
+            clean: "rimraf dist"
+          },
+          dependencies: {
+            fflate: "^0.8.2",
+            "js-yaml": "^4.1.0"
+          },
+          devDependencies: {
+            "@types/js-yaml": "^4.0.9",
+            "@types/node": "^20.14.0",
+            rimraf: "^5.0.7",
+            tsup: "^8.1.0",
+            typescript: "^5.5.2",
+            vitest: "^4.1.9"
+          }
+        };
+      }
+    });
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      buildPack: () => buildPack2,
+      buildTreeArchive: () => buildTreeArchive22,
+      defineRule: () => defineRule,
+      extractPack: () => extractPack2,
+      extractTreeArchive: () => extractTreeArchive22,
+      inspectArchive: () => inspectArchive2,
+      inspectTreeArchive: () => inspectTreeArchive22,
+      scaffoldPack: () => scaffoldPack2
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var path27 = __toESM2(require("path"));
+    var import_js_yaml3 = require("js-yaml");
+    var import_js_yaml = require("js-yaml");
+    var import_crypto = require("crypto");
+    var ENVELOPE_FILENAME = "wairon-pack.yaml";
+    var SUPPORTED_FORMAT_VERSION = 1;
+    var DEFAULTS = {
+      maxEntries: 4096,
+      maxTotalUncompressedBytes: 32 * 1024 * 1024,
+      maxEntryBytes: 8 * 1024 * 1024,
+      maxCompressionRatio: 100,
+      maxDepth: 16
+    };
+    function parseManifest(text) {
+      const raw = (0, import_js_yaml.load)(text);
+      const manifest = validateEnvelope(raw);
+      if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION) {
+        throw new Error("unsupported pack-archive formatVersion (newer than this wairon understands)");
+      }
+      return manifest;
+    }
+    function serializeManifest(manifest) {
+      const clean = {
+        formatVersion: manifest.formatVersion,
+        name: manifest.name,
+        version: manifest.version,
+        kind: manifest.kind,
+        entry: manifest.entry
+      };
+      if (manifest.minWaironVersion !== void 0) clean.minWaironVersion = manifest.minWaironVersion;
+      if (manifest.digest !== void 0) clean.digest = manifest.digest;
+      if (manifest.entryDigests !== void 0) clean.entryDigests = manifest.entryDigests;
+      if (manifest.generatedBy !== void 0) clean.generatedBy = manifest.generatedBy;
+      if (manifest.generatedAt !== void 0) clean.generatedAt = manifest.generatedAt;
+      return (0, import_js_yaml.dump)(clean, { sortKeys: false });
+    }
+    function defaultLimits() {
+      return { ...DEFAULTS };
+    }
+    function planExtraction(entries, limits) {
+      const caps = {
+        maxEntries: limits.maxEntries ?? DEFAULTS.maxEntries,
+        maxTotalUncompressedBytes: limits.maxTotalUncompressedBytes ?? DEFAULTS.maxTotalUncompressedBytes,
+        maxEntryBytes: limits.maxEntryBytes ?? DEFAULTS.maxEntryBytes,
+        maxCompressionRatio: limits.maxCompressionRatio ?? DEFAULTS.maxCompressionRatio,
+        maxDepth: limits.maxDepth ?? DEFAULTS.maxDepth
+      };
+      const approved = [];
+      let total = 0;
+      for (const entry of entries) {
+        if (isSymlinkOrNonRegular(entry.kind) || isStructurallyUnsafePath(entry.path)) {
+          rejectUnsafe();
+        }
+        if (entry.kind === "dir") continue;
+        const normalized = normalizeRelPath(entry.path);
+        if (escapesDestination(normalized) || pathDepth(normalized) > caps.maxDepth) {
+          rejectUnsafe();
+        }
+        if (entry.uncompressedSize > caps.maxEntryBytes || compressionRatio(entry) > caps.maxCompressionRatio) {
+          rejectUnsafe();
+        }
+        approved.push(normalized);
+        total += entry.uncompressedSize;
+      }
+      if (approved.length > caps.maxEntries || total > caps.maxTotalUncompressedBytes) {
+        rejectUnsafe();
+      }
+      return { paths: approved, totalUncompressedBytes: total };
+    }
+    function verifyIdentity(manifest, packName, packVersion) {
+      if (manifest.name !== packName || manifest.version !== packVersion) {
+        throw new Error("envelope identity mismatch (envelope name/version differ from the inner pack manifest)");
+      }
+    }
+    function verifyIntegrity2(manifest, files) {
+      if (!manifest.entryDigests) {
+        return false;
+      }
+      const digests = manifest.entryDigests;
+      for (const file of files) {
+        if (file.path === ENVELOPE_FILENAME) continue;
+        if (sha256(file.contents) !== digests[file.path]) {
+          throw new Error("integrity digest mismatch");
+        }
+      }
+      return true;
+    }
+    function sealIntegrity(manifest, files, generatedBy, generatedAt) {
+      const entryDigests = {};
+      for (const file of files) {
+        if (file.path === ENVELOPE_FILENAME) continue;
+        entryDigests[file.path] = sha256(file.contents);
+      }
+      const digest = sha256(canonicalDigestBytes(entryDigests));
+      return { ...manifest, entryDigests, digest, generatedBy, generatedAt };
+    }
+    function checkCompatibility(manifest, waironVersion) {
+      if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION) {
+        return false;
+      }
+      if (manifest.minWaironVersion && isBelow(waironVersion, manifest.minWaironVersion)) {
+        return false;
+      }
+      return true;
+    }
+    function rejectUnsafe() {
+      throw new Error("reject: unsafe or oversized archive entry (zip-slip / size / ratio / depth guard)");
+    }
+    function validateEnvelope(raw) {
+      if (!raw || typeof raw !== "object") {
+        throw new Error("malformed pack envelope (not a YAML mapping)");
+      }
+      const o = raw;
+      if (typeof o.formatVersion !== "number") throw new Error("pack envelope: formatVersion must be a number");
+      if (typeof o.name !== "string" || !o.name) throw new Error("pack envelope: name is required");
+      if (typeof o.version !== "string" || !o.version) throw new Error("pack envelope: version is required");
+      if (typeof o.kind !== "string" || o.kind !== "declarative" && o.kind !== "code") {
+        throw new Error('pack envelope: kind must be "declarative" or "code"');
+      }
+      if (typeof o.entry !== "string" || !o.entry) throw new Error("pack envelope: entry is required");
+      const manifest = {
+        formatVersion: o.formatVersion,
+        name: o.name,
+        version: o.version,
+        kind: o.kind,
+        entry: o.entry
+      };
+      if (typeof o.minWaironVersion === "string") manifest.minWaironVersion = o.minWaironVersion;
+      if (typeof o.digest === "string") manifest.digest = o.digest;
+      if (o.entryDigests && typeof o.entryDigests === "object") {
+        manifest.entryDigests = o.entryDigests;
+      }
+      if (typeof o.generatedBy === "string") manifest.generatedBy = o.generatedBy;
+      if (typeof o.generatedAt === "string") manifest.generatedAt = o.generatedAt;
+      return manifest;
+    }
+    function isSymlinkOrNonRegular(kind) {
+      return kind !== "file" && kind !== "dir";
+    }
+    function isStructurallyUnsafePath(p) {
+      if (p.includes("\\")) return true;
+      if (/^[A-Za-z]:/.test(p)) return true;
+      if (p.startsWith("/")) return true;
+      return p.split("/").some((seg) => seg === "..");
+    }
+    function normalizeRelPath(p) {
+      return p.split("/").filter((seg) => seg !== "" && seg !== ".").join("/");
+    }
+    function escapesDestination(normalized) {
+      return normalized.startsWith("/") || normalized.split("/").some((seg) => seg === "..");
+    }
+    function pathDepth(normalized) {
+      return normalized.split("/").filter((seg) => seg !== "").length;
+    }
+    function compressionRatio(entry) {
+      if (entry.compressedSize > 0) return entry.uncompressedSize / entry.compressedSize;
+      return entry.uncompressedSize > 0 ? Infinity : 0;
+    }
+    function canonicalDigestBytes(entryDigests) {
+      const lines = Object.keys(entryDigests).sort().map((key) => `${key}:${entryDigests[key]}`).join("\n");
+      return new TextEncoder().encode(lines);
+    }
+    function sha256(data) {
+      return (0, import_crypto.createHash)("sha256").update(data).digest("hex");
+    }
+    function isBelow(running, minimum) {
+      const [rMaj, rMin, rPat] = parseSemverCore(running);
+      const [mMaj, mMin, mPat] = parseSemverCore(minimum);
+      if (rMaj !== mMaj) return rMaj < mMaj;
+      if (rMin !== mMin) return rMin < mMin;
+      return rPat < mPat;
+    }
+    function parseSemverCore(v) {
+      const cleaned = v.trim().replace(/^[^0-9]*/, "");
+      const core = cleaned.split(/[-+]/)[0];
+      const parts = core.split(".").map((n) => parseInt(n, 10));
+      return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+    }
+    var import_js_yaml2 = require("js-yaml");
+    var import_crypto2 = require("crypto");
+    var TREE_ENVELOPE_FILENAME = "wairon-tree.yaml";
+    var SUPPORTED_FORMAT_VERSION2 = 1;
+    var TREE_DEFAULTS = {
+      maxEntries: 2e4,
+      maxTotalUncompressedBytes: 64 * 1024 * 1024,
+      maxEntryBytes: 8 * 1024 * 1024,
+      maxCompressionRatio: 100,
+      maxDepth: 24
+    };
+    var DERIVED_ROOTS = ["generated", "docs"];
+    var EXECUTABLE_EXT_RE = /\.(c|m)?js$/i;
+    var WAI_SEGMENT = ".wai";
+    function parseTreeManifest(text) {
+      const raw = (0, import_js_yaml2.load)(text);
+      const manifest = validateEnvelope2(raw);
+      if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION2) {
+        throw new Error("unsupported tree-archive formatVersion (newer than this wairon understands)");
+      }
+      return manifest;
+    }
+    function serializeTreeManifest(manifest) {
+      const clean = {
+        formatVersion: manifest.formatVersion,
+        projectName: manifest.projectName,
+        roots: manifest.roots
+      };
+      if (manifest.stateId !== void 0) clean.stateId = manifest.stateId;
+      if (manifest.waironVersion !== void 0) clean.waironVersion = manifest.waironVersion;
+      if (manifest.minWaironVersion !== void 0) clean.minWaironVersion = manifest.minWaironVersion;
+      if (manifest.includesDerived !== void 0) clean.includesDerived = manifest.includesDerived;
+      if (manifest.digest !== void 0) clean.digest = manifest.digest;
+      if (manifest.entryDigests !== void 0) clean.entryDigests = manifest.entryDigests;
+      if (manifest.generatedBy !== void 0) clean.generatedBy = manifest.generatedBy;
+      if (manifest.generatedAt !== void 0) clean.generatedAt = manifest.generatedAt;
+      return (0, import_js_yaml2.dump)(clean, { sortKeys: false });
+    }
+    function defaultTreeLimits() {
+      return { ...TREE_DEFAULTS };
+    }
+    function selectTreeFiles(files, includeDerived) {
+      if (includeDerived) {
+        return files;
+      }
+      const kept = files.filter((file) => !isDerivedPath(file.path));
+      return kept;
+    }
+    function planTreeExtraction(entries, limits) {
+      const caps = {
+        maxEntries: limits.maxEntries ?? TREE_DEFAULTS.maxEntries,
+        maxTotalUncompressedBytes: limits.maxTotalUncompressedBytes ?? TREE_DEFAULTS.maxTotalUncompressedBytes,
+        maxEntryBytes: limits.maxEntryBytes ?? TREE_DEFAULTS.maxEntryBytes,
+        maxCompressionRatio: limits.maxCompressionRatio ?? TREE_DEFAULTS.maxCompressionRatio,
+        maxDepth: limits.maxDepth ?? TREE_DEFAULTS.maxDepth
+      };
+      const approved = [];
+      let total = 0;
+      for (const entry of entries) {
+        if (isSymlinkOrNonRegular2(entry.kind) || isStructurallyUnsafePath2(entry.path)) {
+          rejectUnsafe2();
+        }
+        if (entry.kind === "dir") continue;
+        const normalized = normalizeRelPath2(entry.path);
+        if (escapesDestination2(normalized) || pathDepth2(normalized) > caps.maxDepth) {
+          rejectUnsafe2();
+        }
+        if (entry.uncompressedSize > caps.maxEntryBytes || compressionRatio2(entry) > caps.maxCompressionRatio) {
+          rejectUnsafe2();
+        }
+        approved.push(normalized);
+        total += entry.uncompressedSize;
+      }
+      if (approved.length > caps.maxEntries || total > caps.maxTotalUncompressedBytes) {
+        rejectUnsafe2();
+      }
+      return { paths: approved, totalUncompressedBytes: total };
+    }
+    function assertPortableTreePaths(paths) {
+      for (const entryPath of paths) {
+        if (EXECUTABLE_EXT_RE.test(entryPath)) {
+          throw new Error(
+            "refused: the archive carries executable content. Only declarative spec state transfers over this surface; rule/code packs are executable and install via the trusted filesystem (mount into WAIRON_PACKS_DIR, or run `wairon packs add`)."
+          );
+        }
+        if (entryPath !== TREE_ENVELOPE_FILENAME && !isUnderWaiRoot(entryPath)) {
+          throw new Error(`refused: the archive carries an entry outside any spec-tree root ("${entryPath}")`);
+        }
+      }
+    }
+    function verifyTreeIntegrity(manifest, files) {
+      if (!manifest.entryDigests) {
+        return false;
+      }
+      const digests = manifest.entryDigests;
+      for (const file of files) {
+        if (file.path === TREE_ENVELOPE_FILENAME) continue;
+        if (sha2562(file.contents) !== digests[file.path]) {
+          throw new Error("tree integrity digest mismatch");
+        }
+      }
+      return true;
+    }
+    function sealTreeIntegrity(manifest, files, generatedBy, generatedAt) {
+      const entryDigests = {};
+      for (const file of files) {
+        if (file.path === TREE_ENVELOPE_FILENAME) continue;
+        entryDigests[file.path] = sha2562(file.contents);
+      }
+      const digest = sha2562(canonicalDigestBytes2(entryDigests));
+      return { ...manifest, entryDigests, digest, generatedBy, generatedAt };
+    }
+    function checkTreeCompatibility(manifest, waironVersion) {
+      if (Math.trunc(manifest.formatVersion) > SUPPORTED_FORMAT_VERSION2) {
+        return false;
+      }
+      if (manifest.minWaironVersion && isBelow2(waironVersion, manifest.minWaironVersion)) {
+        return false;
+      }
+      return true;
+    }
+    function rejectUnsafe2() {
+      throw new Error("reject: unsafe or oversized tree-archive entry (zip-slip / size / ratio / depth guard)");
+    }
+    function validateEnvelope2(raw) {
+      if (!raw || typeof raw !== "object") {
+        throw new Error("malformed tree envelope (not a YAML mapping)");
+      }
+      const o = raw;
+      if (typeof o.formatVersion !== "number") throw new Error("tree envelope: formatVersion must be a number");
+      if (typeof o.projectName !== "string" || !o.projectName) throw new Error("tree envelope: projectName is required");
+      if (!Array.isArray(o.roots) || o.roots.length === 0 || o.roots.some((r) => typeof r !== "string" || !r)) {
+        throw new Error("tree envelope: roots must be a non-empty list of project-relative directories");
+      }
+      const manifest = {
+        formatVersion: o.formatVersion,
+        projectName: o.projectName,
+        roots: o.roots
+      };
+      if (typeof o.stateId === "string") manifest.stateId = o.stateId;
+      if (typeof o.waironVersion === "string") manifest.waironVersion = o.waironVersion;
+      if (typeof o.minWaironVersion === "string") manifest.minWaironVersion = o.minWaironVersion;
+      if (typeof o.includesDerived === "boolean") manifest.includesDerived = o.includesDerived;
+      if (typeof o.digest === "string") manifest.digest = o.digest;
+      if (o.entryDigests && typeof o.entryDigests === "object") {
+        manifest.entryDigests = o.entryDigests;
+      }
+      if (typeof o.generatedBy === "string") manifest.generatedBy = o.generatedBy;
+      if (typeof o.generatedAt === "string") manifest.generatedAt = o.generatedAt;
+      return manifest;
+    }
+    function isDerivedPath(relPath) {
+      const first = relPath.split("/")[0];
+      return DERIVED_ROOTS.includes(first);
+    }
+    function isUnderWaiRoot(archivePath) {
+      const segments = archivePath.split("/");
+      const at = segments.indexOf(WAI_SEGMENT);
+      return at >= 0 && at < segments.length - 1;
+    }
+    function isSymlinkOrNonRegular2(kind) {
+      return kind !== "file" && kind !== "dir";
+    }
+    function isStructurallyUnsafePath2(p) {
+      if (p.includes("\\")) return true;
+      if (/^[A-Za-z]:/.test(p)) return true;
+      if (p.startsWith("/")) return true;
+      return p.split("/").some((seg) => seg === "..");
+    }
+    function normalizeRelPath2(p) {
+      return p.split("/").filter((seg) => seg !== "" && seg !== ".").join("/");
+    }
+    function escapesDestination2(normalized) {
+      return normalized.startsWith("/") || normalized.split("/").some((seg) => seg === "..");
+    }
+    function pathDepth2(normalized) {
+      return normalized.split("/").filter((seg) => seg !== "").length;
+    }
+    function compressionRatio2(entry) {
+      if (entry.compressedSize > 0) return entry.uncompressedSize / entry.compressedSize;
+      return entry.uncompressedSize > 0 ? Infinity : 0;
+    }
+    function canonicalDigestBytes2(entryDigests) {
+      const lines = Object.keys(entryDigests).sort().map((key) => `${key}:${entryDigests[key]}`).join("\n");
+      return new TextEncoder().encode(lines);
+    }
+    function sha2562(data) {
+      return (0, import_crypto2.createHash)("sha256").update(data).digest("hex");
+    }
+    function isBelow2(running, minimum) {
+      const [rMaj, rMin, rPat] = parseSemverCore2(running);
+      const [mMaj, mMin, mPat] = parseSemverCore2(minimum);
+      if (rMaj !== mMaj) return rMaj < mMaj;
+      if (rMin !== mMin) return rMin < mMin;
+      return rPat < mPat;
+    }
+    function parseSemverCore2(v) {
+      const cleaned = v.trim().replace(/^[^0-9]*/, "");
+      const core = cleaned.split(/[-+]/)[0];
+      const parts = core.split(".").map((n) => parseInt(n, 10));
+      return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+    }
+    var SDK_VERSION = loadVersion();
+    function loadVersion() {
+      try {
+        const pkg = require_package();
+        return pkg.version ?? "0.0.0";
+      } catch {
+        return "0.0.0";
+      }
+    }
+    var enc = (s) => new TextEncoder().encode(s);
+    function render(request) {
+      const version = request.version ?? "0.1.0";
+      let files;
+      if (request.kind === "code") {
+        files = renderCodePack(request.name, version);
+      } else {
+        files = renderDeclarativePack(request.name, version);
+      }
+      if (request.withSkill) {
+        files.push(renderSkillStub(request.name, version));
+      }
+      return files;
+    }
+    function renderDeclarativePack(name, version) {
+      return [
+        { path: "wairon-pack.yaml", contents: enc(declarativeEnvelope(name, version)) },
+        { path: "pack.yaml", contents: enc(declarativeManifest(name, version)) },
+        { path: "README.md", contents: enc(readme(name, "declarative", "pack.yaml")) }
+      ];
+    }
+    function renderCodePack(name, version) {
+      return [
+        { path: "wairon-pack.yaml", contents: enc(codeEnvelope(name, version)) },
+        { path: "package.json", contents: enc(codePackageJson(name, version)) },
+        { path: "tsconfig.json", contents: enc(codeTsconfig()) },
+        { path: "pack.ts", contents: enc(codeEntry(name, version)) },
+        { path: "README.md", contents: enc(readme(name, "code", "pack.cjs")) }
+      ];
+    }
+    function renderSkillStub(name, _version) {
+      const id = slug(name);
+      return { path: `skills/${id}/SKILL.md`, contents: enc(skillStub(name)) };
+    }
+    function declarativeEnvelope(name, version) {
+      return [
+        "formatVersion: 1",
+        `name: ${name}`,
+        `version: ${version}`,
+        "kind: declarative",
+        "entry: pack.yaml",
+        ""
+      ].join("\n");
+    }
+    function codeEnvelope(name, version) {
+      return [
+        "formatVersion: 1",
+        `name: ${name}`,
+        `version: ${version}`,
+        "kind: code",
+        "entry: pack.cjs",
+        `minWaironVersion: ${SDK_VERSION}`,
+        ""
+      ].join("\n");
+    }
+    function declarativeManifest(name, version) {
+      return [
+        `name: ${name}`,
+        `version: ${version}`,
+        "",
+        "# Custom architectural profiles this pack contributes (example, commented):",
+        "# profiles:",
+        "#   my-profile:",
+        "#     family: backend-like",
+        "#     forbiddenStereotypes:",
+        "#       - types: [Adapter]",
+        '#         reason: "Domain components must not touch adapters directly."',
+        "profiles: {}",
+        "",
+        "# Target language / platform tables (example, commented):",
+        "# languages:",
+        "#   rust:",
+        "#     unsupportedFlow: {}",
+        "#     foreignBuiltins: []",
+        "languages: {}",
+        "",
+        "# Reusable, versioned architecture patterns:",
+        "patterns: []",
+        ""
+      ].join("\n");
+    }
+    function codePackageJson(name, version) {
+      const pkg = {
+        name,
+        version,
+        private: true,
+        scripts: {
+          build: "esbuild pack.ts --bundle --platform=node --packages=external --format=cjs --outfile=pack.cjs"
+        },
+        dependencies: {
+          "@wairon/sdk": SDK_VERSION
+        },
+        devDependencies: {
+          esbuild: "^0.21.0",
+          typescript: "^5.0.0"
+        }
+      };
+      return `${JSON.stringify(pkg, null, 2)}
+`;
+    }
+    function codeTsconfig() {
+      const tsconfig = {
+        compilerOptions: {
+          target: "ES2020",
+          module: "CommonJS",
+          moduleResolution: "node",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          declaration: false,
+          noEmit: true
+        },
+        include: ["pack.ts"]
+      };
+      return `${JSON.stringify(tsconfig, null, 2)}
+`;
+    }
+    function codeEntry(name, version) {
+      const code = slug(name).toUpperCase().replace(/-/g, "_");
+      return [
+        "import { defineRule } from '@wairon/sdk';",
+        "import type { RuleContext, Finding } from '@wairon/sdk';",
+        "",
+        "const exampleRule = defineRule({",
+        `  name: '${slug(name)}-example',`,
+        "  description: 'Example architectural rule. Replace with your own doctrine.',",
+        `  codes: ['${code}_EXAMPLE'],`,
+        "  check(ctx: RuleContext): Finding[] {",
+        "    const findings: Finding[] = [];",
+        "    for (const component of ctx.components) {",
+        "      // Inspect the spec tree and push findings as needed.",
+        "      void component;",
+        "    }",
+        "    return findings;",
+        "  },",
+        "});",
+        "",
+        "export default {",
+        `  name: '${name}',`,
+        `  version: '${version}',`,
+        "  rules: [exampleRule],",
+        "};",
+        ""
+      ].join("\n");
+    }
+    function readme(name, kind, entry) {
+      return [
+        `# ${name}`,
+        "",
+        `A wairon ${kind} pack.`,
+        "",
+        `- Envelope: \`wairon-pack.yaml\``,
+        `- Entry: \`${entry}\``,
+        "",
+        "Build an installable `.wpack` archive with `wairon pack build`.",
+        ""
+      ].join("\n");
+    }
+    function skillStub(name) {
+      return [
+        "---",
+        `name: ${name}`,
+        `description: ${name} authoring skill (stub).`,
+        "---",
+        "",
+        `# ${name}`,
+        "",
+        "Describe when this skill applies and what it guides.",
+        ""
+      ].join("\n");
+    }
+    function slug(name) {
+      return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    }
+    var fs17 = __toESM2(require("fs"));
+    var path28 = __toESM2(require("path"));
+    var import_fflate = require_node();
+    var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".hg", ".svn"]);
+    function listEntries(archive) {
+      const symlinks = detectSymlinkNames(archive);
+      const metas = [];
+      (0, import_fflate.unzipSync)(archive, {
+        filter: (info) => {
+          metas.push({
+            path: info.name,
+            uncompressedSize: info.originalSize,
+            compressedSize: info.size,
+            kind: classifyKind(info.name, symlinks)
+          });
+          return false;
+        }
+      });
+      return metas;
+    }
+    function inflateEntry(archive, entryPath) {
+      const inflated = (0, import_fflate.unzipSync)(archive, { filter: (info) => info.name === entryPath });
+      const bytes = inflated[entryPath];
+      if (!bytes) throw new Error(`archive entry not found: ${entryPath}`);
+      return bytes;
+    }
+    function assembleArchive(files) {
+      const zippable = {};
+      for (const file of files) zippable[file.path] = file.contents;
+      const bytes = (0, import_fflate.zipSync)(zippable);
+      return bytes;
+    }
+    function readPackDir(dir) {
+      const files = [];
+      walkPackDir(dir, dir, files);
+      return files;
+    }
+    function writeTree(destDir, files) {
+      for (const file of files) {
+        const absolute = path28.join(destDir, file.path);
+        fs17.mkdirSync(path28.dirname(absolute), { recursive: true });
+        fs17.writeFileSync(absolute, file.contents);
+      }
+    }
+    function classifyKind(name, symlinks) {
+      if (symlinks.has(name)) return "symlink";
+      if (name.endsWith("/")) return "dir";
+      return "file";
+    }
+    function walkPackDir(root, current2, out) {
+      for (const entry of fs17.readdirSync(current2, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          walkPackDir(root, path28.join(current2, entry.name), out);
+        } else if (entry.isFile()) {
+          const absolute = path28.join(current2, entry.name);
+          const relative22 = path28.relative(root, absolute).split(path28.sep).join("/");
+          out.push({ path: relative22, contents: fs17.readFileSync(absolute) });
+        }
+      }
+    }
+    function detectSymlinkNames(archive) {
+      const names = /* @__PURE__ */ new Set();
+      try {
+        const eocd = findEocd(archive);
+        if (eocd < 0) return names;
+        let p = readU32(archive, eocd + 16);
+        const count = readU16(archive, eocd + 10);
+        const decoder = new TextDecoder();
+        for (let i = 0; i < count; i++) {
+          if (readU32(archive, p) !== 33639248) break;
+          const versionMadeBy = readU16(archive, p + 4);
+          const nameLen = readU16(archive, p + 28);
+          const extraLen = readU16(archive, p + 30);
+          const commentLen = readU16(archive, p + 32);
+          const externalAttrs = readU32(archive, p + 38);
+          const name = decoder.decode(archive.subarray(p + 46, p + 46 + nameLen));
+          if (versionMadeBy >> 8 === 3) {
+            const unixMode = externalAttrs >>> 16 & 65535;
+            if ((unixMode & 61440) === 40960) names.add(name);
+          }
+          p += 46 + nameLen + extraLen + commentLen;
+        }
+      } catch {
+        return names;
+      }
+      return names;
+    }
+    function findEocd(buf) {
+      const minRecord = 22;
+      const lowerBound = Math.max(0, buf.length - (minRecord + 65535));
+      for (let i = buf.length - minRecord; i >= lowerBound; i--) {
+        if (readU32(buf, i) === 101010256) return i;
+      }
+      return -1;
+    }
+    function readU16(buf, off) {
+      return buf[off] | buf[off + 1] << 8;
+    }
+    function readU32(buf, off) {
+      return (buf[off] | buf[off + 1] << 8 | buf[off + 2] << 16 | buf[off + 3] << 24) >>> 0;
+    }
+    var decode = (b) => new TextDecoder().decode(b);
+    var encode = (s) => new TextEncoder().encode(s);
+    function scaffoldPack(request) {
+      const files = render(request);
+      writeTree(request.targetDir, files);
+      return files.map((file) => path27.join(request.targetDir, file.path));
+    }
+    function buildPack(sourceDir) {
+      const files = readPackDir(sourceDir);
+      const envelope = files.find((file) => file.path === ENVELOPE_FILENAME);
+      if (!envelope) {
+        throw new Error("pack build requires a wairon-pack.yaml envelope (run `wairon pack init` to scaffold one)");
+      }
+      const manifest = parseManifest(decode(envelope.contents));
+      const identity = readInnerIdentity(files, manifest);
+      verifyIdentity(manifest, identity.name, identity.version);
+      const sealed = sealIntegrity(manifest, files, `@wairon/sdk@${SDK_VERSION}`, (/* @__PURE__ */ new Date()).toISOString());
+      const sealedText = serializeManifest(sealed);
+      const finalFiles = upsertEnvelope(files, sealedText);
+      const archiveBytes = assembleArchive(finalFiles);
+      const info = buildInfo(sealed, finalFiles);
+      const suggestedFileName = `${sealed.name}-${sealed.version}.wpack`;
+      return { archive: archiveBytes, info, suggestedFileName };
+    }
+    function inspectArchive(archiveBytes) {
+      const entries = listEntries(archiveBytes);
+      if (!entries.some((entry) => entry.path === ENVELOPE_FILENAME)) {
+        throw new Error("not a .wpack archive (missing wairon-pack.yaml envelope)");
+      }
+      const envelopeBytes = inflateEntry(archiveBytes, ENVELOPE_FILENAME);
+      const manifest = parseManifest(decode(envelopeBytes));
+      const compatible = checkCompatibility(manifest, SDK_VERSION);
+      const fileEntries = entries.filter((entry) => entry.kind === "file");
+      const totalUncompressedBytes = entries.reduce((sum, entry) => sum + entry.uncompressedSize, 0);
+      const info = {
+        name: manifest.name,
+        version: manifest.version,
+        kind: manifest.kind,
+        entry: manifest.entry,
+        formatVersion: manifest.formatVersion,
+        entryCount: fileEntries.length,
+        totalUncompressedBytes,
+        compatible
+      };
+      if (manifest.minWaironVersion !== void 0) info.minWaironVersion = manifest.minWaironVersion;
+      return info;
+    }
+    function extractPack(archiveBytes, destDir, limits) {
+      const effectiveLimits = limits === void 0 ? defaultLimits() : limits;
+      const entries = listEntries(archiveBytes);
+      const plan = planExtraction(entries, effectiveLimits);
+      const files = [];
+      for (const approvedPath of plan.paths) {
+        const contents = inflateEntry(archiveBytes, approvedPath);
+        files.push({ path: approvedPath, contents });
+      }
+      const envelope = files.find((file) => file.path === ENVELOPE_FILENAME);
+      if (!envelope) {
+        throw new Error("not a .wpack archive (missing wairon-pack.yaml envelope)");
+      }
+      const manifest = parseManifest(decode(envelope.contents));
+      verifyIntegrity2(manifest, files);
+      const directory = path27.resolve(destDir);
+      writeTree(directory, files);
+      const result = {
+        directory,
+        entryPath: manifest.entry,
+        manifest,
+        name: manifest.name,
+        kind: manifest.kind,
+        entryCount: files.length
+      };
+      return result;
+    }
+    function buildTreeArchive3(roots, projectName, stateId, includeDerived) {
+      const files = [];
+      const packedRoots = [];
+      for (const root of roots) {
+        const rootFiles = readPackDir(root.waiDir);
+        const portable = selectTreeFiles(rootFiles, includeDerived === true);
+        const prefix = treeRootPrefix(root.relativePath);
+        for (const file of portable) files.push({ path: `${prefix}${file.path}`, contents: file.contents });
+        packedRoots.push(normalizeRootPath(root.relativePath));
+      }
+      if (files.length === 0) {
+        throw new Error("tree export found no spec-tree files under the supplied roots");
+      }
+      const manifest = {
+        formatVersion: 1,
+        projectName,
+        roots: packedRoots,
+        waironVersion: SDK_VERSION,
+        includesDerived: includeDerived === true
+      };
+      if (stateId !== void 0) manifest.stateId = stateId;
+      const sealed = sealTreeIntegrity(
+        manifest,
+        files,
+        `@wairon/sdk@${SDK_VERSION}`,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+      const sealedText = serializeTreeManifest(sealed);
+      const finalFiles = [
+        ...files.filter((file) => file.path !== TREE_ENVELOPE_FILENAME),
+        { path: TREE_ENVELOPE_FILENAME, contents: encode(sealedText) }
+      ];
+      const archiveBytes = assembleArchive(finalFiles);
+      const suggestedFileName = `${slugify(projectName)}.waitree`;
+      return { archive: archiveBytes, manifest: sealed, suggestedFileName, fileCount: files.length };
+    }
+    function inspectTreeArchive3(archiveBytes) {
+      const entries = listEntries(archiveBytes);
+      if (!entries.some((entry) => entry.path === TREE_ENVELOPE_FILENAME)) {
+        throw new Error("not a .waitree archive (missing wairon-tree.yaml envelope)");
+      }
+      const envelopeBytes = inflateEntry(archiveBytes, TREE_ENVELOPE_FILENAME);
+      const manifest = parseTreeManifest(decode(envelopeBytes));
+      const compatible = checkTreeCompatibility(manifest, SDK_VERSION);
+      const fileEntries = entries.filter((entry) => entry.kind === "file");
+      const totalUncompressedBytes = entries.reduce((sum, entry) => sum + entry.uncompressedSize, 0);
+      return { manifest, entryCount: fileEntries.length, totalUncompressedBytes, compatible };
+    }
+    function extractTreeArchive3(archiveBytes, destDir, limits, refuseExecutableEntries) {
+      const effectiveLimits = limits === void 0 ? defaultTreeLimits() : limits;
+      const entries = listEntries(archiveBytes);
+      const plan = planTreeExtraction(entries, effectiveLimits);
+      if (refuseExecutableEntries === true) {
+        assertPortableTreePaths(plan.paths);
+      }
+      const files = [];
+      for (const approvedPath of plan.paths) {
+        const contents = inflateEntry(archiveBytes, approvedPath);
+        files.push({ path: approvedPath, contents });
+      }
+      const envelope = files.find((file) => file.path === TREE_ENVELOPE_FILENAME);
+      if (!envelope) {
+        throw new Error("not a .waitree archive (missing wairon-tree.yaml envelope)");
+      }
+      const manifest = parseTreeManifest(decode(envelope.contents));
+      verifyTreeIntegrity(manifest, files);
+      const directory = path27.resolve(destDir);
+      writeTree(directory, files);
+      const result = {
+        destDir: directory,
+        manifest,
+        roots: manifest.roots,
+        writtenPaths: files.map((file) => file.path)
+      };
+      return result;
+    }
+    function treeRootPrefix(relativePath) {
+      const normalized = normalizeRootPath(relativePath);
+      return normalized === "." ? ".wai/" : `${normalized}/.wai/`;
+    }
+    function normalizeRootPath(relativePath) {
+      const posix3 = relativePath.split(path27.sep).join("/").replace(/^\.\//, "").replace(/\/+$/, "");
+      return posix3 === "" || posix3 === "." ? "." : posix3;
+    }
+    function slugify(projectName) {
+      const slug2 = projectName.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+      return slug2 || "spec-tree";
+    }
+    function readInnerIdentity(files, manifest) {
+      const innerPath = manifest.kind === "code" ? "package.json" : manifest.entry;
+      const inner = files.find((file) => file.path === innerPath);
+      if (!inner) throw new Error(`pack build: inner pack manifest "${innerPath}" is missing`);
+      const parsed = manifest.kind === "code" ? JSON.parse(decode(inner.contents)) : (0, import_js_yaml3.load)(decode(inner.contents));
+      const name = parsed?.name;
+      const version = parsed?.version;
+      if (typeof name !== "string" || typeof version !== "string") {
+        throw new Error(`pack build: inner pack manifest "${innerPath}" lacks a name/version`);
+      }
+      return { name, version };
+    }
+    function upsertEnvelope(files, envelopeText) {
+      const others = files.filter((file) => file.path !== ENVELOPE_FILENAME);
+      return [...others, { path: ENVELOPE_FILENAME, contents: encode(envelopeText) }];
+    }
+    function buildInfo(manifest, files) {
+      const totalUncompressedBytes = files.reduce((sum, file) => sum + file.contents.length, 0);
+      const info = {
+        name: manifest.name,
+        version: manifest.version,
+        kind: manifest.kind,
+        entry: manifest.entry,
+        formatVersion: manifest.formatVersion,
+        entryCount: files.length,
+        totalUncompressedBytes,
+        compatible: true
+      };
+      if (manifest.minWaironVersion !== void 0) info.minWaironVersion = manifest.minWaironVersion;
+      return info;
+    }
+    function defineRule(rule) {
+      return rule;
+    }
+    function scaffoldPack2(request) {
+      return scaffoldPack(request);
+    }
+    function buildPack2(sourceDir) {
+      return buildPack(sourceDir);
+    }
+    function inspectArchive2(archive) {
+      return inspectArchive(archive);
+    }
+    function extractPack2(archive, destDir, limits) {
+      return extractPack(archive, destDir, limits);
+    }
+    function buildTreeArchive22(roots, projectName, stateId, includeDerived) {
+      return buildTreeArchive3(roots, projectName, stateId, includeDerived);
+    }
+    function inspectTreeArchive22(archive) {
+      return inspectTreeArchive3(archive);
+    }
+    function extractTreeArchive22(archive, destDir, limits, refuseExecutableEntries) {
+      return extractTreeArchive3(archive, destDir, limits, refuseExecutableEntries);
+    }
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AI_PATHS: () => AI_PATHS,
+  ARCHITECT_AGENT_ID: () => ARCHITECT_AGENT_ID,
+  ARCHITECT_TEMPLATE_ID: () => ARCHITECT_TEMPLATE_ID,
+  AgentBriefSchema: () => AgentBriefSchema,
+  AgentRecordSchema: () => AgentRecordSchema,
+  AgentStatusSchema: () => AgentStatusSchema,
+  AgentTemplateSchema: () => AgentTemplateSchema,
+  AssertionSelectorSchema: () => AssertionSelectorSchema,
+  BACKEND_COMMANDS: () => BACKEND_COMMANDS,
+  BUILTIN_PROFILES: () => BUILTIN_PROFILES,
+  BUILTIN_TYPES: () => BUILTIN_TYPES,
+  BoundaryItemSchema: () => BoundaryItemSchema,
+  BuiltinTargetConfigSchema: () => BuiltinTargetConfigSchema,
+  BuiltinTargetSchema: () => BuiltinTargetSchema,
+  BundleNotFoundError: () => BundleNotFoundError,
+  CONTEXT_PATHS: () => CONTEXT_PATHS,
+  CatchClauseSchema: () => CatchClauseSchema,
+  ClaudeExporter: () => ClaudeExporter,
+  ComplexityRuleConfigSchema: () => ComplexityRuleConfigSchema,
+  ComponentSpecSchema: () => ComponentSpecSchema,
+  ComponentTypeSchema: () => ComponentTypeSchema,
+  ConfigValidationError: () => ConfigValidationError,
+  ConformanceTierSchema: () => ConformanceTierSchema,
+  CustomExporter: () => CustomExporter,
+  CustomTargetConfigSchema: () => CustomTargetConfigSchema,
+  CustomTargetSchema: () => CustomTargetSchema,
+  DEFAULT_TARGET_DIRS: () => DEFAULT_TARGET_DIRS,
+  DatabaseSpecSchema: () => DatabaseSpecSchema,
+  DeclarativePackSchema: () => DeclarativePackSchema,
+  DesignDepthSchema: () => DesignDepthSchema,
+  DiagramConfigSchema: () => DiagramConfigSchema,
+  DispatchBindingSchema: () => DispatchBindingSchema,
+  DocumentationRuleConfigSchema: () => DocumentationRuleConfigSchema,
+  DomainSchema: () => DomainSchema,
+  DomainTypeSchema: () => DomainTypeSchema,
+  DurabilitySchema: () => DurabilitySchema,
+  EndpointSchema: () => EndpointSchema,
+  EventBindingSchema: () => EventBindingSchema,
+  ExtDataSchema: () => ExtDataSchema,
+  ExternalLinkSchema: () => ExternalLinkSchema,
+  ExternalLinkTypeSchema: () => ExternalLinkTypeSchema,
+  GITHUB_REPO: () => GITHUB_REPO,
+  GLOBAL_PACKS_DEFAULT: () => GLOBAL_PACKS_DEFAULT,
+  GeminiExporter: () => GeminiExporter,
+  GroupSpecSchema: () => GroupSpecSchema,
+  GuaranteeSchema: () => GuaranteeSchema,
+  HttpMethodSchema: () => HttpMethodSchema,
+  ImplementationSpecSchema: () => ImplementationSpecSchema,
+  InterfaceSpecSchema: () => InterfaceSpecSchema,
+  InvariantSchema: () => InvariantSchema,
+  LANGUAGE_MARKERS: () => LANGUAGE_MARKERS,
+  LanguagePackDefSchema: () => LanguagePackDefSchema,
+  LifecycleEntrypointSchema: () => LifecycleEntrypointSchema,
+  LintAllowSchema: () => LintAllowSchema,
+  LintConfigSchema: () => LintConfigSchema,
+  LoopKindSchema: () => LoopKindSchema,
+  MethodImplementationSchema: () => MethodImplementationSchema,
+  MethodParamSchema: () => MethodParamSchema,
+  MethodSignatureSchema: () => MethodSignatureSchema,
+  NamedOpenApiSpecSchema: () => NamedOpenApiSpecSchema,
+  NamingRuleConfigSchema: () => NamingRuleConfigSchema,
+  NarrativeDetailSchema: () => NarrativeDetailSchema,
+  NarrativeStepSchema: () => NarrativeStepSchema,
+  NarrativeStepTypeSchema: () => NarrativeStepTypeSchema,
+  OutputTargetSchema: () => OutputTargetSchema,
+  PACK_DIR_ENTRIES: () => PACK_DIR_ENTRIES,
+  PATTERN_TYPES: () => PATTERN_TYPES,
+  PROJECT_KINDS: () => PROJECT_KINDS,
+  PackAssertionSchema: () => PackAssertionSchema,
+  PackInstructionBlockSchema: () => PackInstructionBlockSchema,
+  PackSelectionSchema: () => PackSelectionSchema,
+  PackSkillSchema: () => PackSkillSchema,
+  ParallelBranchSchema: () => ParallelBranchSchema,
+  PathsConfigSchema: () => PathsConfigSchema,
+  PatternDefSchema: () => PatternDefSchema,
+  PatternRefSchema: () => PatternRefSchema,
+  PortalAuthSchema: () => PortalAuthSchema,
+  PortalAuthSchemeSchema: () => PortalAuthSchemeSchema,
+  PortalTypeSchema: () => PortalTypeSchema,
+  ProfileDefSchema: () => ProfileDefSchema,
+  ProfileSelectionSubjectSchema: () => ProfileSelectionSubjectSchema,
+  ProjectConfigSchema: () => ProjectConfigSchema,
+  ProjectNotInitializedError: () => ProjectNotInitializedError,
+  ProjectProfileSelectionSchema: () => ProjectProfileSelectionSchema,
+  PublicInterfaceSchema: () => PublicInterfaceSchema,
+  PublicInterfaceTypeSchema: () => PublicInterfaceTypeSchema,
+  RegistrySchema: () => RegistrySchema,
+  RequirementItemSchema: () => RequirementItemSchema,
+  RulesConfigSchema: () => RulesConfigSchema,
+  SCAN_EXCLUDE_DIRS: () => SCAN_EXCLUDE_DIRS,
+  SDD_RULES: () => SDD_RULES,
+  SEMANTIC_GUARANTEES: () => SEMANTIC_GUARANTEES,
+  SUPPORTED_ALIASES: () => SUPPORTED_ALIASES,
+  SURFACE_AUDIENCES: () => SURFACE_AUDIENCES,
+  SkillResourceNotFoundError: () => SkillResourceNotFoundError,
+  SpecIdSchema: () => SpecIdSchema,
+  SpecStatusSchema: () => SpecStatusSchema,
+  SpecWorkspace: () => SpecWorkspace,
+  SubsystemSpecSchema: () => SubsystemSpecSchema,
+  SurfaceAudienceSchema: () => SurfaceAudienceSchema,
+  SurfaceContractEntrySchema: () => SurfaceContractEntrySchema,
+  SurfaceOriginSchema: () => SurfaceOriginSchema,
+  SurfaceSnapshotSchema: () => SurfaceSnapshotSchema,
+  SurfaceTypeDefSchema: () => SurfaceTypeDefSchema,
+  SwitchCaseSchema: () => SwitchCaseSchema,
+  SystemPublicInterfaceSchema: () => SystemPublicInterfaceSchema,
+  SystemSpecSchema: () => SystemSpecSchema,
+  TargetConfigSchema: () => TargetConfigSchema,
+  TemplateNotFoundError: () => TemplateNotFoundError,
+  TemplateSchema: () => TemplateSchema,
+  TopologyConfigSchema: () => TopologyConfigSchema,
+  TransportSchema: () => TransportSchema,
+  TrustedLinkSchema: () => TrustedLinkSchema,
+  TypeFieldSchema: () => TypeFieldSchema,
+  TypeKindSchema: () => TypeKindSchema,
+  TypeMethodSchema: () => TypeMethodSchema,
+  TypeSpecSchema: () => TypeSpecSchema,
+  UNVERSIONED: () => UNVERSIONED,
+  UnknownAgentError: () => UnknownAgentError,
+  VariantDefSchema: () => VariantDefSchema,
+  WAIRON_MANAGED_BANNER: () => WAIRON_MANAGED_BANNER,
+  WAIRON_MANAGED_MARKER: () => WAIRON_MANAGED_MARKER,
+  WAIRON_VERSION: () => WAIRON_VERSION,
+  WaironError: () => WaironError,
+  activeTargetTypes: () => activeTargetTypes,
+  addFreeStandingDomain: () => addFreeStandingDomain,
+  aiDir: () => aiDir,
+  aiPathsAt: () => aiPathsAt,
+  applySpecStatus: () => applySpecStatus,
+  assertContainedProjectPath: () => assertContainedProjectPath,
+  assertProjectInitialized: () => assertProjectInitialized,
+  assertionFullCode: () => assertionFullCode,
+  audienceRank: () => audienceRank,
+  backendCommand: () => backendCommand,
+  backfillChainedSubprojectConfigs: () => backfillChainedSubprojectConfigs,
+  buildCanvasDataModel: () => buildCanvasDataModel,
+  buildGraphModel: () => buildGraphModel,
+  buildProjectGraph: () => buildProjectGraph,
+  buildRuleContext: () => buildRuleContext,
+  buildServerInstructions: () => buildServerInstructions2,
+  buildTreeArchive: () => buildTreeArchive2,
+  checkChildSurfaceFreshness: () => checkChildSurfaceFreshness,
+  checkSkillFreshness: () => checkSkillFreshness,
+  clearLoaderIssues: () => clearLoaderIssues,
+  collectPromotableSpecs: () => collectPromotableSpecs,
+  commitStagedTree: () => commitStagedTree,
+  composeAgentBrief: () => composeAgentBrief,
+  composeRuleSequence: () => composeRuleSequence,
+  composeVariantGuidance: () => composeVariantGuidance,
+  computeGateStateId: () => computeGateStateId,
+  computePackDigest: () => computePackDigest,
+  computeParentStateId: () => computeParentStateId,
+  computeStateId: () => computeStateId,
+  computeStateIdAt: () => computeStateIdAt,
+  contextDir: () => contextDir,
+  createAgentRecord: () => createAgentRecord,
+  createChainedSubsystem: () => createChainedSubsystem,
+  createEmptyRegistry: () => createEmptyRegistry,
+  createEmptyTopologyConfig: () => createEmptyTopologyConfig,
+  createStagingDir: () => createStagingDir,
+  defaultPackSelections: () => defaultPackSelections,
+  defaultTargetConfig: () => defaultTargetConfig,
+  deleteComponentSpec: () => deleteComponentSpec,
+  deleteGroupSpec: () => deleteGroupSpec,
+  deleteImplementationSpec: () => deleteImplementationSpec,
+  deleteInterfaceSpec: () => deleteInterfaceSpec,
+  deleteSubsystemSpec: () => deleteSubsystemSpec,
+  deleteTypeSpec: () => deleteTypeSpec,
+  deriveSubsystemDomains: () => deriveSubsystemDomains,
+  detectDomainCandidates: () => detectDomainCandidates,
+  diagnoseProjectPacks: () => diagnoseProjectPacks,
+  diagramSetIndex: () => diagramSetIndex,
+  discardStagingDir: () => discardStagingDir,
+  discoverPacks: () => discoverPacks,
+  dryRunSerializeSpecs: () => dryRunSerializeSpecs,
+  emptyExtensions: () => emptyExtensions,
+  ensureDir: () => ensureDir,
+  ensureProjectInitialized: () => ensureProjectInitialized,
+  exportSddSkills: () => exportSddSkills,
+  exportSpecTree: () => exportSpecTree,
+  exportSurface: () => exportSurface,
+  externalizeSubsystem: () => externalizeSubsystem,
+  extractGenericTypeVariables: () => extractGenericTypeVariables,
+  extractTreeArchive: () => extractTreeArchive2,
+  extractTypeGenerics: () => extractTypeGenerics,
+  extractTypeIdentifiers: () => extractTypeIdentifiers,
+  extractTypesFromSignature: () => extractTypesFromSignature,
+  findChainingParent: () => findChainingParent,
+  findChainingSubprojectsMissingConfig: () => findChainingSubprojectsMissingConfig,
+  findDomain: () => findDomain,
+  findLegacySpecFiles: () => findLegacySpecFiles,
+  findProjectRoot: () => findProjectRoot,
+  findSystemRoot: () => findSystemRoot,
+  fromOpenApi: () => fromOpenApi,
+  fromProjectRoot: () => fromProjectRoot,
+  generateAgent: () => generateAgent,
+  generateAll: () => generateAll,
+  generateChildSnapshots: () => generateChildSnapshots,
+  generateComponentDiagram: () => generateComponentDiagram,
+  generateDiagramSet: () => generateDiagramSet,
+  generateSequenceDiagram: () => generateSequenceDiagram,
+  getComponentPath: () => getComponentPath,
+  getExporter: () => getExporter,
+  getGroupPath: () => getGroupPath,
+  getImplementationPath: () => getImplementationPath,
+  getInterfacePath: () => getInterfacePath,
+  getLoaderIssues: () => getLoaderIssues,
+  getProjectRoot: () => getProjectRoot,
+  getProjectRootOverride: () => getProjectRootOverride,
+  getRequestProjectRoot: () => getRequestProjectRoot,
+  getSnapshot: () => getSnapshot,
+  getSubprojectPrefix: () => getSubprojectPrefix,
+  getSubsystemPath: () => getSubsystemPath,
+  getTypePath: () => getTypePath,
+  globalPacksDir: () => globalPacksDir,
+  globalPacksEnabled: () => globalPacksEnabled,
+  globalTemplatesDir: () => globalTemplatesDir,
+  globalVariantsDir: () => globalVariantsDir,
+  hasArchitectureContext: () => hasArchitectureContext,
+  hasAuthoredSpecs: () => hasAuthoredSpecs,
+  hasContext: () => hasContext,
+  hasSpecTree: () => hasSpecTree,
+  hashGateState: () => hashGateState,
+  importSpecTree: () => importSpecTree,
+  importSurface: () => importSurface,
+  inspectTreeArchive: () => inspectTreeArchive2,
+  installPackFromDirectory: () => installPackFromDirectory,
+  internalizeSubsystem: () => internalizeSubsystem,
+  invalidateSpecCache: () => invalidateSpecCache,
+  isOpenApiDocument: () => isOpenApiDocument,
+  isProjectInitialized: () => isProjectInitialized,
+  listChainedRoots: () => listChainedRoots,
+  listDirectChainedSubprojects: () => listDirectChainedSubprojects,
+  listExternalInterfaces: () => listExternalInterfaces,
+  listFiles: () => listFiles,
+  listFilesRecursive: () => listFilesRecursive,
+  listFreeStandingDomains: () => listFreeStandingDomains,
+  listInstalledPacks: () => listInstalledPacks,
+  listResources: () => listResources,
+  listRules: () => listRules,
+  listSkillNames: () => listSkillNames,
+  listSkillResources: () => listSkillResources,
+  listSnapshots: () => listSnapshots,
+  listTemplateIds: () => listTemplateIds,
+  loadAgentOverride: () => loadAgentOverride,
   loadComponentSpec: () => loadComponentSpec,
   loadComponentSpecs: () => loadComponentSpecs,
   loadExtensionPacks: () => loadExtensionPacks,
@@ -18013,8 +21422,8 @@ function walkForPackages(projectRoot, currentDir, depth, results) {
   }
 }
 function pathToId(relPath) {
-  const basename10 = path18.basename(relPath);
-  return basename10.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const basename11 = path18.basename(relPath);
+  return basename11.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function pathToName(relPath) {
   const id = pathToId(relPath);
@@ -18771,6 +22180,7 @@ If \`.wai/specs/\` exists, the wairon SDD workflow is active; otherwise ignore i
   7. **Subprojects & Namespacing**: If a subsystem uses \`projectPath\` delegation, target its specs using namespaced IDs (e.g. \`subsystem::component\`). Use leading \`::\` to target root (e.g. \`::shared::type\`) and \`super::\` to go up a level (e.g. \`super::sibling\`). wairon automatically resolves the path and strips the prefix on writes.`;
 
 // src/core/context.ts
+init_domains();
 function contextDir(...segments) {
   return aiDir("context", ...segments);
 }
@@ -18800,15 +22210,12 @@ function writeArchitectureContext(content) {
   writeFile(CONTEXT_PATHS.architectureMd(), content);
 }
 function renderDomainsDoc() {
-  const { resolveDomains: resolveDomains2 } = (init_domains(), __toCommonJS(domains_exports));
-  const domains = resolveDomains2();
-  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const domains = resolveDomains();
   const lines = [
     versionStamp(),
     `# Domains`,
     ``,
     `> Auto-generated by wairon. The human developer rebuilds this with \`wairon generate\`.  `,
-    `> Last updated: ${today}`,
     ``
   ];
   if (domains.length === 0) {
@@ -18911,6 +22318,157 @@ function syncContextFiles() {
 init_surfaces();
 init_openapi();
 init_packstore();
+
+// src/core/treetransfer.ts
+var fs16 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var sdkPortal = __toESM(require_dist());
+init_loader();
+init_fs();
+init_specs2();
+init_statehash();
+var STAGING_PREFIX = ".wai-staging-";
+var BACKUP_DIR = ".wai-backups";
+function buildTreeArchive2(roots, projectName, stateId, includeDerived) {
+  return sdkPortal.buildTreeArchive(roots, projectName, stateId, includeDerived);
+}
+function inspectTreeArchive2(archive) {
+  return sdkPortal.inspectTreeArchive(archive);
+}
+function extractTreeArchive2(archive, destDir, refuseExecutableEntries) {
+  const limits = void 0;
+  return sdkPortal.extractTreeArchive(archive, destDir, limits, refuseExecutableEntries);
+}
+function hasSpecTree(root) {
+  if (pathExists(aiPathsAt(root).projectConfig())) {
+    return true;
+  }
+  return false;
+}
+function hasAuthoredSpecs(root) {
+  const paths = aiPathsAt(root);
+  const specsDir = paths.specsDir();
+  if (!pathExists(specsDir)) {
+    return false;
+  }
+  const systemIndex = path22.resolve(paths.specsSystem());
+  for (const file of listFilesRecursive(specsDir, ".yaml")) {
+    if (path22.resolve(file) !== systemIndex) {
+      return true;
+    }
+  }
+  return false;
+}
+function createStagingDir(destDir) {
+  const root = path22.resolve(destDir);
+  fs16.mkdirSync(root, { recursive: true });
+  const stagingDir = fs16.mkdtempSync(path22.join(root, STAGING_PREFIX));
+  return stagingDir;
+}
+function commitStagedTree(stagingDir, destDir, roots, backupExisting) {
+  const root = path22.resolve(destDir);
+  const backupDir = path22.join(root, BACKUP_DIR, timestampSlug());
+  let backedUp = false;
+  for (const rootRel of roots) {
+    const relative8 = rootRel === "." ? "" : rootRel;
+    const stagedSpecDir = path22.join(stagingDir, relative8, ".wai");
+    if (!fs16.existsSync(stagedSpecDir)) continue;
+    const liveSpecDir = liveSpecDirFor(path22.join(root, relative8));
+    if (backupExisting && liveSpecDir && fs16.existsSync(liveSpecDir)) {
+      const backupTarget = path22.join(backupDir, relative8, path22.basename(liveSpecDir));
+      fs16.mkdirSync(path22.dirname(backupTarget), { recursive: true });
+      fs16.renameSync(liveSpecDir, backupTarget);
+      backedUp = true;
+    } else if (liveSpecDir && fs16.existsSync(liveSpecDir)) {
+      fs16.rmSync(liveSpecDir, { recursive: true, force: true });
+    }
+    const target = path22.join(root, relative8, ".wai");
+    fs16.mkdirSync(path22.dirname(target), { recursive: true });
+    if (fs16.existsSync(target)) fs16.rmSync(target, { recursive: true, force: true });
+    fs16.renameSync(stagedSpecDir, target);
+  }
+  if (backedUp) {
+    return backupDir;
+  }
+  return "";
+}
+function discardStagingDir(stagingDir) {
+  try {
+    fs16.rmSync(stagingDir, { recursive: true, force: true });
+  } catch {
+  }
+}
+function exportSpecTree(includeDerived) {
+  const system = loadSystemSpec();
+  if (!system) {
+    throw new Error("no spec tree to export at this project root");
+  }
+  const chained = listChainedRoots();
+  const root = getProjectRoot();
+  const candidates = [
+    { relativePath: ".", waiDir: aiPathsAt(root).root() },
+    ...chained.map((rel2) => ({ relativePath: rel2, waiDir: aiPathsAt(path22.resolve(root, rel2)).root() }))
+  ];
+  const roots = candidates.filter((source) => pathExists(source.waiDir));
+  const stateId = computeStateId();
+  const built = buildTreeArchive2(roots, system.name, stateId.digest, includeDerived);
+  const result = {
+    archive: built.archive,
+    suggestedFileName: built.suggestedFileName,
+    projectName: built.manifest.projectName,
+    roots: built.manifest.roots,
+    fileCount: built.fileCount,
+    stateId: stateId.digest
+  };
+  return result;
+}
+function importSpecTree(archive, options) {
+  const info = inspectTreeArchive2(archive);
+  if (!info.compatible) {
+    throw new Error("incompatible .waitree archive (format or minimum wairon version)");
+  }
+  const destDir = path22.resolve(options.destDir ?? getProjectRoot());
+  const occupied = hasSpecTree(destDir);
+  const authored = hasAuthoredSpecs(destDir);
+  if (authored && options.replaceExisting !== true) {
+    throw new Error(
+      "the destination already holds an authored spec tree; pass replaceExisting to move it aside and import over it"
+    );
+  }
+  const stagingDir = createStagingDir(destDir);
+  let extraction;
+  try {
+    extraction = extractTreeArchive2(archive, stagingDir, options.refuseExecutableEntries);
+  } catch (err) {
+    discardStagingDir(stagingDir);
+    throw err;
+  }
+  const backupPath = commitStagedTree(stagingDir, destDir, extraction.roots, occupied);
+  discardStagingDir(stagingDir);
+  invalidateSpecCache();
+  const result = {
+    destDir,
+    projectName: extraction.manifest.projectName,
+    roots: extraction.roots,
+    fileCount: extraction.writtenPaths.length,
+    replaced: occupied
+  };
+  if (backupPath) result.backupPath = backupPath;
+  if (extraction.manifest.stateId) result.stateId = extraction.manifest.stateId;
+  return result;
+}
+function liveSpecDirFor(rootDir) {
+  const modern = path22.join(rootDir, ".wai");
+  if (fs16.existsSync(modern)) return modern;
+  const legacy = path22.join(rootDir, ".wairon");
+  if (fs16.existsSync(legacy)) return legacy;
+  return null;
+}
+function timestampSlug() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+
+// src/core/index.ts
 init_extensions();
 init_agent_resolver();
 
@@ -18919,7 +22477,7 @@ var WAIRON_MANAGED_MARKER = "wairon:managed";
 var WAIRON_MANAGED_BANNER = `<!-- ${WAIRON_MANAGED_MARKER} \u2014 generated by \`wairon generate\`; do not edit, changes are overwritten -->`;
 
 // src/exporters/claude.ts
-var path22 = __toESM(require("path"));
+var path23 = __toESM(require("path"));
 init_fs();
 var ClaudeExporter = class {
   constructor() {
@@ -18928,7 +22486,7 @@ var ClaudeExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".claude/agents";
-    return path22.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path23.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -18949,7 +22507,7 @@ var ClaudeExporter = class {
 };
 
 // src/exporters/custom.ts
-var path23 = __toESM(require("path"));
+var path24 = __toESM(require("path"));
 init_fs();
 var CustomExporter = class {
   constructor() {
@@ -18960,7 +22518,7 @@ var CustomExporter = class {
     if (!("outputDir" in target)) {
       throw new Error("CustomExporter requires target.outputDir");
     }
-    return path23.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
+    return path24.resolve(projectRoot, target.outputDir, `${agent.id.replace(/::/g, "--")}.md`);
   }
   export(ctx) {
     const { agent, target, renderedInstructions } = ctx;
@@ -18983,7 +22541,7 @@ var CustomExporter = class {
 };
 
 // src/exporters/gemini.ts
-var path24 = __toESM(require("path"));
+var path25 = __toESM(require("path"));
 init_fs();
 var GeminiExporter = class {
   constructor() {
@@ -18992,7 +22550,7 @@ var GeminiExporter = class {
   outputPath(ctx) {
     const { agent, target, projectRoot } = ctx;
     const outputDir = "outputDir" in target ? target.outputDir : ".gemini/agents";
-    return path24.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
+    return path25.resolve(projectRoot, outputDir, `${agent.id.replace(/::/g, "--")}.yaml`);
   }
   export(ctx) {
     const { agent, renderedInstructions } = ctx;
@@ -19017,7 +22575,7 @@ function yamlString(value) {
 }
 
 // src/exporters/generate.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 init_fs();
 
 // src/exporters/registry.ts
@@ -19084,7 +22642,7 @@ function resolveExpectedOutputPaths(agents, projectConfig, projectRoot = getProj
       const targetConfig = resolveTargetConfig(agentTarget, projectConfig);
       if (!targetConfig) continue;
       const ctx = { agent, projectRoot, target: targetConfig };
-      expected.add(path25.resolve(getExporter(targetConfig).outputPath(ctx)));
+      expected.add(path26.resolve(getExporter(targetConfig).outputPath(ctx)));
     }
   }
   return expected;
@@ -19298,10 +22856,12 @@ init_yaml();
   buildProjectGraph,
   buildRuleContext,
   buildServerInstructions,
+  buildTreeArchive,
   checkChildSurfaceFreshness,
   checkSkillFreshness,
   clearLoaderIssues,
   collectPromotableSpecs,
+  commitStagedTree,
   composeAgentBrief,
   composeRuleSequence,
   composeVariantGuidance,
@@ -19315,6 +22875,7 @@ init_yaml();
   createChainedSubsystem,
   createEmptyRegistry,
   createEmptyTopologyConfig,
+  createStagingDir,
   defaultPackSelections,
   defaultTargetConfig,
   deleteComponentSpec,
@@ -19327,15 +22888,18 @@ init_yaml();
   detectDomainCandidates,
   diagnoseProjectPacks,
   diagramSetIndex,
+  discardStagingDir,
   discoverPacks,
   dryRunSerializeSpecs,
   emptyExtensions,
   ensureDir,
   ensureProjectInitialized,
   exportSddSkills,
+  exportSpecTree,
   exportSurface,
   externalizeSubsystem,
   extractGenericTypeVariables,
+  extractTreeArchive,
   extractTypeGenerics,
   extractTypeIdentifiers,
   extractTypesFromSignature,
@@ -19371,14 +22935,19 @@ init_yaml();
   globalTemplatesDir,
   globalVariantsDir,
   hasArchitectureContext,
+  hasAuthoredSpecs,
   hasContext,
+  hasSpecTree,
   hashGateState,
+  importSpecTree,
   importSurface,
+  inspectTreeArchive,
   installPackFromDirectory,
   internalizeSubsystem,
   invalidateSpecCache,
   isOpenApiDocument,
   isProjectInitialized,
+  listChainedRoots,
   listDirectChainedSubprojects,
   listExternalInterfaces,
   listFiles,