@fabricorg/fabric-gen 0.7.5 → 0.7.7

package/dist/cli.cjs

@@ -1,634 +1,11 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// index.ts
-var import_promises = require("fs/promises");
-var import_node_crypto = require("crypto");
-var import_node_path = __toESM(require("path"), 1);
-var import_node_url = require("url");
-var import_compiler = require("@fabricorg/compiler");
-var import_manifest = require("@fabricorg/platform/manifest");
-var import_gen_capability = require("@fabricorg/gen-capability");
-var import_gen_docs = require("@fabricorg/gen-docs");
-var import_gen_events = require("@fabricorg/gen-events");
-var import_gen_types = require("@fabricorg/gen-types");
-var import_gen_prisma = require("@fabricorg/gen-prisma");
-var import_gen_graphql = require("@fabricorg/gen-graphql");
-var import_gen_sdui = require("@fabricorg/gen-sdui");
-var import_sdui_composer = require("@fabricorg/sdui-composer");
-var import_gen_conformance = require("@fabricorg/gen-conformance");
-var import_assembly = require("@fabricorg/assembly");
-var import_sdui_release = require("@fabricorg/sdui-release");
-var GENERATOR_TARGETS = {
-  types: import_gen_types.typesGenerator,
-  events: import_gen_events.eventsGenerator,
-  capability: import_gen_capability.capabilityGenerator,
-  docs: import_gen_docs.docsGenerator,
-  prisma: import_gen_prisma.prismaGenerator,
-  graphql: import_gen_graphql.graphqlGenerator,
-  sdui: import_gen_sdui.sduiGenerator,
-  conformance: import_gen_conformance.conformanceGenerator
-};
-var compareCanonicalStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-var usage = [
-  "Usage:",
-  "  fabric-gen init capability <namespace> [--directory <path>]",
-  "  fabric-gen export --module <file> [--export <name>] --out <manifest.json>",
-  "  fabric-gen init experience <application> [--directory <path>]",
-  "  fabric-gen check-application [--config <path>]",
-  "  fabric-gen promote-experience --config <path> --key <pem> [--out <path>]",
-  "  fabric-gen --input <manifest.json> --out <directory> [--targets <list>] [--check]"
-].join("\n");
-var FabricGenUsageError = class extends Error {
-  name = "FabricGenUsageError";
-};
-function fabricGenCliExitCode(error) {
-  return error instanceof FabricGenUsageError ? 2 : 1;
-}
-function flagValue(args2, flag) {
-  const index = args2.indexOf(flag);
-  if (index < 0) return void 0;
-  const value = args2[index + 1];
-  if (!value || value.startsWith("--")) throw new FabricGenUsageError(usage);
-  return value;
-}
-async function runFabricGenCommand(args2) {
-  if (args2[0] === "export") {
-    const moduleFile = flagValue(args2, "--module");
-    const out = flagValue(args2, "--out");
-    if (!moduleFile || !out) throw new FabricGenUsageError(usage);
-    const result2 = await exportModuleManifestFile({ moduleFile, out, exportName: flagValue(args2, "--export") });
-    return `Exported "${result2.namespace}" from ${result2.exportName} to ${out}: ${result2.objectTypes} object types, ${result2.actions} actions, ${result2.eventTypes} event types.`;
-  }
-  if (args2[0] === "init") {
-    if (!args2[2] || args2[2].startsWith("--")) {
-      throw new FabricGenUsageError(usage);
-    }
-    const name = args2[2];
-    const directory = flagValue(args2, "--directory") ?? name;
-    if (args2[1] === "capability") {
-      const result2 = await initializeCapability({ directory, namespace: name });
-      return `Initialized capability "${name}" with ${result2.created.length} files.`;
-    }
-    if (args2[1] === "experience") {
-      const result2 = await initializeExperience({ directory, application: name });
-      return `Initialized experience integration "${name}" with ${result2.created.length} files.`;
-    }
-    throw new FabricGenUsageError(usage);
-  }
-  if (args2[0] === "promote-experience") {
-    const configPath = flagValue(args2, "--config");
-    const privateKeyPath = flagValue(args2, "--key");
-    if (!configPath) throw new FabricGenUsageError("promote-experience requires --config.");
-    if (!privateKeyPath) throw new FabricGenUsageError("promote-experience requires --key.");
-    const outputPath = flagValue(args2, "--out");
-    const result2 = await promoteExperience({
-      configPath,
-      privateKeyPath,
-      ...outputPath ? { outputPath } : {}
-    });
-    return [
-      `Promoted ${result2.application} release ${result2.releaseDigest.slice(0, 12)} against assembly ${result2.assemblyDigest.slice(0, 12)}.`,
-      `Routes: ${result2.routes.views} views, ${result2.routes.intents} intents.`,
-      `Wrote ${result2.outputPath}`
-    ].join("\n");
-  }
-  if (args2[0] === "check-application") {
-    const configPath = flagValue(args2, "--config") ?? "fabric.application.json";
-    const result2 = await checkApplication({ configPath });
-    return `Checked "${result2.application}": ${result2.capabilities} capabilities, ${result2.releases} releases.`;
-  }
-  const inputPath = flagValue(args2, "--input");
-  const outputDirectory = flagValue(args2, "--out");
-  if (!inputPath || !outputDirectory) throw new FabricGenUsageError(usage);
-  const result = await generateFromManifest({
-    inputPath,
-    outputDirectory,
-    targets: (flagValue(args2, "--targets") ?? "types,events,capability,docs").split(",").filter(Boolean),
-    check: args2.includes("--check")
-  });
-  return `${args2.includes("--check") ? "Checked" : "Generated"} ${result.files.length} files.`;
-}
-function experienceReadme(application) {
-  return [
-    `# ${application} experience integration`,
-    "",
-    "| File | What it is |",
-    "| --- | --- |",
-    "| `fabric.experience.ts` | The server runtime and gateway, wired to your host. |",
-    "| `fabric.component-pack.ts` | The components this application is allowed to render. |",
-    "| `fabric.application.json` | What the deployment gate reads. |",
-    "| `fabric.assembly.lock.json` | The resolved assembly. Empty until you add capabilities. |",
-    "| `fabric.runtime.json` | Capabilities the running host actually registers. |",
-    "",
-    "## Install",
-    "",
-    "The scaffolded files import three packages this generator does not install:",
-    "",
-    "```bash",
-    "pnpm add @fabricorg/experience-runtime @fabricorg/experience-gateway @fabricorg/component-pack",
-    "```",
-    "",
-    "## Check it",
-    "",
-    "```bash",
-    "fabric-gen check-application --config fabric.application.json",
-    "```",
-    "",
-    "It passes on the scaffold and keeps passing as you add capabilities, as long",
-    "as the lockfile, the runtime capabilities, and every promoted release agree.",
-    "Regenerate the lockfile from your composition root with `resolveAssembly`;",
-    "`fabric.runtime.json` must list what that same root registers with the host,",
-    "which is what stops a deployment from serving a plan its host cannot answer.",
-    ""
-  ].join("\n");
-}
-async function initializeExperience(options) {
-  if (!/^[a-z][a-z0-9-]*$/.test(options.application)) {
-    throw new Error("Application name must use lowercase letters, numbers, and hyphens.");
-  }
-  const functionName = options.application.split("-").map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
-  const files = [
-    [
-      import_node_path.default.join(options.directory, "fabric.experience.ts"),
-      [
-        'import { createExperienceServerRuntime } from "@fabricorg/experience-runtime/server";',
-        'import { createExperienceGateway } from "@fabricorg/experience-gateway";',
-        "",
-        `export const create${functionName}ExperienceRuntime = (`,
-        "	options: Parameters<typeof createExperienceServerRuntime>[0],",
-        ") => createExperienceServerRuntime(options);",
-        "",
-        `export const create${functionName}ExperienceGateway = (`,
-        "	options: Parameters<typeof createExperienceGateway>[0],",
-        ") => createExperienceGateway(options);",
-        ""
-      ].join("\n")
-    ],
-    [
-      import_node_path.default.join(options.directory, "fabric.component-pack.ts"),
-      [
-        'import { defineComponentPack } from "@fabricorg/component-pack";',
-        "",
-        `export const define${functionName}ComponentPack = (artifactDigest: string) =>`,
-        "	defineComponentPack({",
-        `		name: "${options.application}",`,
-        `		namespace: "${options.application}",`,
-        '		version: "0.1.0",',
-        "		artifactDigest,",
-        '		tokenContract: { name: "fabric-family", version: "1.0.0" },',
-        "		components: {",
-        '			Text: { module: "./components/text.js", roles: ["content"], slots: [] },',
-        "		},",
-        "	});",
-        ""
-      ].join("\n")
-    ],
-    [
-      import_node_path.default.join(options.directory, "fabric.application.json"),
-      `${JSON.stringify({
-        formatVersion: 1,
-        application: options.application,
-        assembly: "./fabric.assembly.lock.json",
-        runtimeCapabilities: "./fabric.runtime.json",
-        releases: []
-      }, null, 2)}
-`
-    ],
-    // The application config names these two files, so the scaffold has to
-    // produce them. Without them `fabric-gen check-application`, the very
-    // next step, failed on a missing file rather than on anything the
-    // author had done. The lockfile is resolved here, not hand-written, so
-    // it carries a real assembly digest from the first commit.
-    [
-      import_node_path.default.join(options.directory, "fabric.assembly.lock.json"),
-      `${JSON.stringify((0, import_assembly.resolveAssembly)({
-        manifest: {
-          formatVersion: 2,
-          application: options.application,
-          capabilities: [],
-          componentPacks: [],
-          bindings: [],
-          contracts: []
-        },
-        capabilities: [],
-        componentPacks: []
-      }).lockfile, null, 2)}
-`
-    ],
-    [
-      import_node_path.default.join(options.directory, "fabric.runtime.json"),
-      "[]\n"
-    ],
-    [
-      import_node_path.default.join(options.directory, "README.md"),
-      experienceReadme(options.application)
-    ]
-  ];
-  await (0, import_promises.mkdir)(options.directory, { recursive: true });
-  const created = [];
-  try {
-    for (const [file, content] of files) {
-      await (0, import_promises.writeFile)(file, content, { encoding: "utf8", flag: "wx" });
-      created.push(file);
-    }
-  } catch (error) {
-    await Promise.all(created.map((file) => (0, import_promises.rm)(file, { force: true })));
-    if (error.code === "EEXIST") {
-      throw new Error("Refusing to overwrite an existing experience integration file.");
-    }
-    throw error;
-  }
-  return { created };
-}
-async function readJson(file) {
-  return JSON.parse(await (0, import_promises.readFile)(file, "utf8"));
-}
-function assertApplicationCheckConfig(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Application check configuration must be a JSON object.");
-  }
-  const config = value;
-  if (config.formatVersion !== 1) throw new Error("Application check configuration formatVersion must be 1.");
-  if (typeof config.assembly !== "string" || !config.assembly) {
-    throw new Error("Application check configuration assembly must be a file path.");
-  }
-  if (typeof config.runtimeCapabilities !== "string" || !config.runtimeCapabilities) {
-    throw new Error("Application check configuration runtimeCapabilities must be a file path.");
-  }
-  if (!Array.isArray(config.releases) || !config.releases.every((entry) => typeof entry === "string" && entry)) {
-    throw new Error("Application check configuration releases must be an array of file paths.");
-  }
-}
-async function checkApplication(options) {
-  const configValue = await readJson(options.configPath);
-  assertApplicationCheckConfig(configValue);
-  const base = import_node_path.default.dirname(options.configPath);
-  const resolve = (file) => import_node_path.default.resolve(base, file);
-  const assembly = await readJson(resolve(configValue.assembly));
-  (0, import_assembly.assertAssemblyLockfile)(assembly);
-  const runtimeCapabilities = await readJson(
-    resolve(configValue.runtimeCapabilities)
-  );
-  if (!Array.isArray(runtimeCapabilities)) {
-    throw new Error("Runtime capabilities must be a JSON array.");
-  }
-  (0, import_assembly.assertAssemblyRuntimeCompatible)(assembly, runtimeCapabilities);
-  for (const releasePath of configValue.releases) {
-    const release = await readJson(resolve(releasePath));
-    try {
-      (0, import_sdui_release.assertSduiReleaseIntegrity)(release);
-    } catch (error) {
-      throw new Error(
-        `Experience release "${releasePath}" is invalid: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (release.assemblyDigest !== assembly.assemblyDigest) {
-      throw new Error(
-        `Experience release "${release.document.name}@${release.document.version}" belongs to assembly "${release.assemblyDigest}", not "${assembly.assemblyDigest}".`
-      );
-    }
-  }
-  return {
-    application: assembly.application,
-    capabilities: assembly.capabilities.length,
-    releases: configValue.releases.length,
-    assemblyDigest: assembly.assemblyDigest
-  };
-}
-async function exportModuleManifestFile(options) {
-  const absolute = import_node_path.default.resolve(options.moduleFile);
-  const loaded = await importAuthoredModule(absolute, options.moduleFile);
-  const candidates = Object.entries(loaded).filter(([, value]) => isFabricModuleLike(value));
-  let entry;
-  if (options.exportName) {
-    const named = loaded[options.exportName];
-    if (named === void 0) throw new Error(`"${options.moduleFile}" has no export named "${options.exportName}". It exports: ${Object.keys(loaded).join(", ") || "nothing"}.`);
-    if (!isFabricModuleLike(named)) throw new Error(`Export "${options.exportName}" of "${options.moduleFile}" is not a FabricModule: it has no string "namespace".`);
-    entry = [options.exportName, named];
-  } else if (candidates.length === 1) {
-    entry = candidates[0];
-  } else if (candidates.length === 0) {
-    throw new Error(`"${options.moduleFile}" exports no FabricModule. Export one, with a string "namespace", or name it with --export.`);
-  } else {
-    throw new Error(`"${options.moduleFile}" exports ${candidates.length} modules (${candidates.map(([name]) => name).join(", ")}). Choose one with --export.`);
-  }
-  const manifest = (0, import_manifest.exportModuleManifest)(entry[1]);
-  (0, import_compiler.compileManifestBundle)({ manifestVersion: 2, modules: [manifest] });
-  await (0, import_promises.mkdir)(import_node_path.default.dirname(import_node_path.default.resolve(options.out)), { recursive: true });
-  await (0, import_promises.writeFile)(import_node_path.default.resolve(options.out), `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-  return {
-    namespace: manifest.namespace,
-    exportName: entry[0],
-    objectTypes: manifest.objectTypes.length,
-    actions: manifest.actions.length,
-    eventTypes: manifest.eventTypes.length
-  };
-}
-async function importAuthoredModule(absolute, display) {
-  try {
-    return await import((0, import_node_url.pathToFileURL)(absolute).href);
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    const readAsCommonJs = /Unexpected token '(export|import)'|Cannot use import statement outside a module/.test(reason);
-    if (readAsCommonJs && /\.[cm]?ts$/.test(absolute)) {
-      const sibling = import_node_path.default.join(import_node_path.default.dirname(absolute), `.fabric-gen-${process.pid}-${import_node_path.default.basename(absolute, import_node_path.default.extname(absolute))}.mts`);
-      try {
-        await (0, import_promises.writeFile)(sibling, await (0, import_promises.readFile)(absolute, "utf8"), "utf8");
-        return await import((0, import_node_url.pathToFileURL)(sibling).href);
-      } catch (retried) {
-        const retriedReason = retried instanceof Error ? retried.message : String(retried);
-        throw new Error(`Could not load module file "${display}": ${retriedReason}
-A TypeScript file needs a runtime that strips types (Node 22.18 or newer); otherwise point --module at the built JavaScript.`);
-      } finally {
-        await (0, import_promises.rm)(sibling, { force: true });
-      }
-    }
-    throw new Error(`Could not load module file "${display}": ${reason}
-A TypeScript file needs a runtime that strips types (Node 22.18 or newer); otherwise point --module at the built JavaScript.`);
-  }
-}
-function isFabricModuleLike(value) {
-  return typeof value === "object" && value !== null && typeof value.namespace === "string";
-}
-async function initializeCapability(options) {
-  if (!/^[a-z][a-z0-9-]*$/.test(options.namespace)) {
-    throw new Error("Capability namespace must use lowercase letters, numbers, and hyphens.");
-  }
-  const displayName = options.namespace.split("-").map((part, index) => index === 0 ? `${part.charAt(0).toUpperCase()}${part.slice(1)}` : part).join(" ");
-  const modulePath = import_node_path.default.join(options.directory, "module.ts");
-  const readmePath = import_node_path.default.join(options.directory, "README.md");
-  for (const file of [readmePath, modulePath]) {
-    try {
-      await (0, import_promises.access)(file);
-      throw new Error(`Refusing to overwrite existing file "${file}".`);
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith("Refusing to overwrite")) throw error;
-      if (error.code !== "ENOENT") throw error;
-    }
-  }
-  const module2 = [
-    `import type { ActionDefinition } from "@fabricorg/platform/actions";`,
-    `import type { FabricModule } from "@fabricorg/platform/modules";`,
-    "",
-    `/** One governed action. Every field below is checked when the manifest is exported. */`,
-    `const recordExample: ActionDefinition = {`,
-    `	actionId: "${options.namespace}.record_example",`,
-    `	namespace: "${options.namespace}",`,
-    "	version: 1,",
-    '	kind: "atomic",',
-    "	idempotent: true,",
-    "	mutatesDomain: true,",
-    '	emitsEvents: ["ExampleRecorded"],',
-    "	// The six execution dimensions. A strict certification profile requires all of them.",
-    "	execution: {",
-    '		connectivity: "online-required",',
-    '		authorityMoment: "execution",',
-    '		idempotency: "required",',
-    '		completion: "immediate",',
-    '		consistency: "authoritative-now",',
-    '		sensitivity: "internal",',
-    "	},",
-    "	schema: {",
-    "		parse(value: unknown): { exampleId: string } {",
-    "			const input = value as { exampleId?: unknown };",
-    '			if (typeof input?.exampleId !== "string") throw new Error("exampleId is required");',
-    "			return { exampleId: input.exampleId };",
-    "		},",
-    "		safeParse(value: unknown) {",
-    "			try {",
-    "				return { success: true as const, data: this.parse(value) };",
-    "			} catch (error) {",
-    '				return { success: false as const, error: { issues: [{ path: ["exampleId"], message: error instanceof Error ? error.message : String(error) }] } };',
-    "			}",
-    "		},",
-    "	},",
-    "	handler: async (_context, parameters) => ({",
-    "		success: true,",
-    "		data: {",
-    "			...(parameters as { exampleId: string }),",
-    "			_events: [{",
-    '				eventType: "ExampleRecorded",',
-    '				entityType: "Example",',
-    "				entityId: (parameters as { exampleId: string }).exampleId,",
-    "				payload: parameters,",
-    "			}],",
-    "		},",
-    "	}),",
-    "};",
-    "",
-    `export const ${camelCase(options.namespace)}Module: FabricModule = {`,
-    `	namespace: "${options.namespace}",`,
-    '	version: "0.1.0",',
-    "	capability: {",
-    `		displayName: "${displayName}",`,
-    `		description: "Governed ${displayName.toLowerCase()} capability.",`,
-    '		stability: "experimental",',
-    "	},",
-    "	objectTypes: [{",
-    '		type: "Example",',
-    "		schema: {",
-    '			type: "object",',
-    '			properties: { exampleId: { type: "string" } },',
-    '			required: ["exampleId"],',
-    "		},",
-    "	}],",
-    `	idPrefixes: [{ prefix: "exm", name: "Example", module: "${options.namespace}" }],`,
-    '	eventTypes: [{ eventType: "ExampleRecorded", schemaVersion: 1 }],',
-    "	actions: [recordExample],",
-    "};",
-    ""
-  ].join("\n");
-  const readme = [
-    `# ${displayName}`,
-    "",
-    "`module.ts` is the source of truth. It is TypeScript, so the shape of every",
-    "action, object type, and event is checked as you write it.",
-    "",
-    "## The loop",
-    "",
-    "```bash",
-    "# 1. Export the authored module to the normalized manifest the generators read.",
-    "fabric-gen export --module module.ts --out fabric.manifest.json",
-    "",
-    "# 2. Generate types, event contracts, the usage contract, and docs.",
-    "fabric-gen --input fabric.manifest.json --out generated",
-    "",
-    "# 3. In CI, prove the generated files match the manifest.",
-    "fabric-gen --input fabric.manifest.json --out generated --check",
-    "```",
-    "",
-    "Commit both `fabric.manifest.json` and `generated/`. The manifest is the",
-    "contract other capabilities and applications compile against; regenerating",
-    "is how a consumer learns what changed.",
-    "",
-    "## What to edit",
-    "",
-    "- **Object types** carry a portable JSON Schema. They become generated TypeScript types.",
-    "- **Actions** declare six execution dimensions. A host refuses an action whose",
-    "  declaration does not match how it is invoked, so declare them honestly.",
-    "- **Events** are the capability's public vocabulary. Adding a field is compatible;",
-    "  removing or retyping one is not.",
-    ""
-  ].join("\n");
-  await (0, import_promises.mkdir)(options.directory, { recursive: true });
-  const created = [];
-  try {
-    for (const [file, content] of [
-      [readmePath, readme],
-      [modulePath, module2]
-    ]) {
-      await (0, import_promises.writeFile)(file, content, { encoding: "utf8", flag: "wx" });
-      created.push(file);
-    }
-  } catch (error) {
-    await Promise.all(created.map((file) => (0, import_promises.rm)(file, { force: true })));
-    if (error.code === "EEXIST") {
-      throw new Error("Refusing to overwrite a file created during capability initialization.");
-    }
-    throw error;
-  }
-  return { created };
-}
-function camelCase(namespace) {
-  return namespace.split("-").map((part, index) => index === 0 ? part : `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
-}
-async function generateFromManifest(options) {
-  const input = JSON.parse(await (0, import_promises.readFile)(options.inputPath, "utf8"));
-  if (!input || typeof input !== "object" || Array.isArray(input)) throw new Error("Manifest input must be a JSON object.");
-  const bundle = "modules" in input ? input : { manifestVersion: input.manifestVersion, modules: [input] };
-  const ir = (0, import_compiler.compileManifestBundle)(bundle);
-  const files = (await Promise.all(options.targets.map(async (name) => {
-    const target = GENERATOR_TARGETS[name];
-    if (!target) throw new Error(`Unknown generator target "${name}".`);
-    return (await (0, import_compiler.runGenerator)(target, ir)).map((file) => ({ ...file, path: `${name}/${file.path}` }));
-  }))).flat().sort((left, right) => compareCanonicalStrings(left.path, right.path));
-  const expected = new Set(files.map((file) => file.path));
-  const existing = await listFiles(options.outputDirectory);
-  const selectedPrefixes = options.targets.map((target) => `${target}/`);
-  const stale = existing.filter((file) => selectedPrefixes.some((prefix) => file.startsWith(prefix)) && !expected.has(file));
-  if (!options.check) await Promise.all(stale.map((file) => (0, import_promises.rm)(import_node_path.default.join(options.outputDirectory, file), { force: true })));
-  const changed = [];
-  for (const file of files) {
-    const target = import_node_path.default.join(options.outputDirectory, file.path);
-    let current;
-    try {
-      current = await (0, import_promises.readFile)(target, "utf8");
-    } catch {
-      current = void 0;
-    }
-    if (current !== file.content) {
-      changed.push(file.path);
-      if (!options.check) {
-        await (0, import_promises.mkdir)(import_node_path.default.dirname(target), { recursive: true });
-        await (0, import_promises.writeFile)(target, file.content, "utf8");
-      }
-    }
-  }
-  if (options.check && (changed.length || stale.length)) throw new Error(`Generated artifacts drifted: ${[...changed, ...stale.map((file) => `stale:${file}`)].join(", ")}`);
-  return { changed, stale, files };
-}
-async function listFiles(directory, prefix = "") {
-  let entries;
-  try {
-    entries = await (0, import_promises.readdir)(directory, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const nested = await Promise.all(entries.map((entry) => entry.isDirectory() ? listFiles(import_node_path.default.join(directory, entry.name), `${prefix}${entry.name}/`) : [`${prefix}${entry.name}`]));
-  return nested.flat().sort();
-}
-function assertExperiencePromotionConfig(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Experience promotion configuration must be a JSON object.");
-  }
-  const config = value;
-  if (config.formatVersion !== 1) throw new Error("Experience promotion configuration formatVersion must be 1.");
-  for (const field of ["application", "issuer", "keyId", "assembly", "release"]) {
-    if (typeof config[field] !== "string" || !config[field]) {
-      throw new Error(`Experience promotion configuration ${field} must be a non-empty string.`);
-    }
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(config.application)) {
-    throw new Error("Experience promotion configuration application must be lowercase letters, numbers, and hyphens.");
-  }
-  if (!Array.isArray(config.contracts) || !config.contracts.every((entry) => typeof entry === "string" && entry)) {
-    throw new Error("Experience promotion configuration contracts must be an array of file paths.");
-  }
-  const known = /* @__PURE__ */ new Set(["formatVersion", "application", "issuer", "keyId", "assembly", "release", "contracts"]);
-  for (const field of Object.keys(config)) {
-    if (/key|secret|credential|token|pem|password/i.test(field) && field !== "keyId") {
-      throw new Error(`Experience promotion configuration must not carry "${field}"; pass the signing key with --key.`);
-    }
-    if (!known.has(field)) {
-      throw new Error(`Experience promotion configuration has an unknown field "${field}".`);
-    }
-  }
-}
-async function promoteExperience(options) {
-  const configValue = await readJson(options.configPath);
-  assertExperiencePromotionConfig(configValue);
-  const base = import_node_path.default.dirname(options.configPath);
-  const resolve = (file) => import_node_path.default.resolve(base, file);
-  const assembly = await readJson(resolve(configValue.assembly));
-  (0, import_assembly.assertAssemblyLockfile)(assembly);
-  const release = await readJson(resolve(configValue.release));
-  (0, import_sdui_release.assertSduiReleaseIntegrity)(release);
-  const contracts = await Promise.all(
-    configValue.contracts.map(async (file) => await readJson(resolve(file)))
-  );
-  const privateKey = (0, import_node_crypto.createPrivateKey)(await (0, import_promises.readFile)(options.privateKeyPath, "utf8"));
-  const promoted = await (0, import_sdui_composer.promoteExperienceRelease)({
-    application: configValue.application,
-    release,
-    contracts,
-    assembly,
-    issuer: configValue.issuer,
-    signer: (0, import_sdui_composer.createEs256ReleaseSigner)({ keyId: configValue.keyId, privateKey })
-  });
-  const outputPath = options.outputPath ? import_node_path.default.resolve(options.outputPath) : resolve(`${configValue.application}.experience-release.jws`);
-  await (0, import_promises.mkdir)(import_node_path.default.dirname(outputPath), { recursive: true });
-  await (0, import_promises.writeFile)(outputPath, `${promoted.compactJws}
-`, "utf8");
-  return {
-    application: configValue.application,
-    releaseDigest: release.releaseDigest,
-    assemblyDigest: assembly.assemblyDigest,
-    routes: {
-      views: promoted.release.routes.views.length,
-      intents: promoted.release.routes.intents.length
-    },
-    outputPath
-  };
-}
-
-// cli.ts
-var args = process.argv.slice(2);
-runFabricGenCommand(args).then((message) => console.log(message)).catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exitCode = fabricGenCliExitCode(error);
+const require_index = require("./index.cjs");
+//#region cli.ts
+const args = process.argv.slice(2);
+require_index.runFabricGenCommand(args).then((message) => console.log(message)).catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = require_index.fabricGenCliExitCode(error);
 });
+//#endregion
+
 //# sourceMappingURL=cli.cjs.map