@fabricorg/fabric-gen 0.3.2 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,136 @@
 # Changelog
 
+## 0.6.0
+
+### Minor Changes
+
+- e9a2f5e: Add `fabric-gen promote-experience`, which turns a validated release into a signed one from a
+  declared configuration: the assembly it was validated against, the release, and the usage contracts
+  routes are compiled from.
+
+  The signing key is a `--key` argument rather than a configuration field, and a configuration that
+  carries one is refused, because a configuration file is the kind of thing that ends up committed.
+
+### Patch Changes
+
+- a598fb9: Close the remaining review findings.
+
+  **One capability-reference grammar.** `sdui-release` accepted any name after the namespace while
+  `sdui-composer` rejected `/`, so a view named `orders/reports/daily` produced a release that validated
+  and then died at promotion with nothing wrong upstream to point at. Both now share
+  `parseCapabilityRef`, tightened to lowercase path segments matching what the platform permits for a
+  view name. Two views in one contract that reduce to the same reference are reported as
+  `ambiguous_capability_reference` at validation rather than surfacing as an ambiguous route later.
+
+  **A bounded replay window.** A client-supplied `capturedAt` had no lower bound. Deferring it to the
+  Host looked safe and was not: the Host checks staleness only when the capture-authority adapter
+  supplies an `expiresAt`, and skips the execution-time expiry check entirely for actions governed at
+  capture. A gateway that accepts replay must now declare `maxOfflineReplayAgeMs`, and the instant must
+  be RFC 3339 with an explicit offset.
+
+  **One token-set grammar.** `document.tokenSet` accepted names and versions that `supportedTokenSets`
+  rejected, while validation treats the two fields as interchangeable.
+
+  **Port requirements narrow as they are checked.** A requirement for a standard _and_ a version could
+  be satisfied by two different adapters covering one constraint each. `requirement.standard.version`
+  was declared and never read.
+
+- 0d1f6f6: Close what a third independent review found, including two defects introduced by the previous fix.
+
+  **Offline replay counted refusals as successes.** `PlatformHost` reports a refused capture by
+  _returning_ `reconciliation_required` with the reason, not by throwing, so the queue took its success
+  branch, deleted the capture and reported it applied. The reconciliation path was unreachable. Replay
+  now reads the returned outcome. The already-applied branch is removed entirely: a repeated key
+  returns the original invocation without complaint, and an idempotency _conflict_ means the key was
+  reused for a materially different command, so that capture was never applied and is kept rather than
+  discarded.
+
+  **`deriveAuthorizationGrants` defaulted open and reached the signed artifact.** Requirements are
+  optional metadata, so a capability declaring none granted everything to an actor holding nothing.
+  Grants are also carried onto a release unexamined and promotion signs a route for each, so a surplus
+  grant became a signed route to a capability the screen never renders. Undeclared requirements now
+  withhold by default, and `document` scopes the result to references the screen actually binds.
+
+  Several conformance checks could not fail: a search suite passed an adapter returning nothing, a
+  payments suite passed a double-charger that omitted a provider reference, an identity suite certified
+  timestamps the scope check then rejected on every request, an MFE probe could be refused for an
+  unrelated reason, and a channel check accepted any exception as a refusal. Each now proves what it
+  claims. Promotion configuration rejects anything reading like a key rather than two spellings,
+  rejects unknown fields, and constrains the application name that decides the default output path.
+
+- Updated dependencies [8ce5e06]
+- Updated dependencies [a598fb9]
+- Updated dependencies [8f75ac9]
+- Updated dependencies [9a5b18a]
+- Updated dependencies [9b2e55b]
+- Updated dependencies [0d1f6f6]
+- Updated dependencies [274d948]
+  - @fabricorg/sdui-release@0.5.0
+  - @fabricorg/sdui-composer@0.2.0
+  - @fabricorg/assembly@0.4.0
+  - @fabricorg/gen-conformance@1.0.0
+  - @fabricorg/gen-graphql@4.0.0
+
+## 0.5.0
+
+### Minor Changes
+
+- Add `fabric-gen init experience` for wiring the supported experience tier into an
+  existing application without generating a competing shell.
+
+### Patch Changes
+
+- Updated dependencies
+  - @fabricorg/sdui-release@0.4.0
+
+## 0.4.1
+
+### Patch Changes
+
+- Updated dependencies
+- Updated dependencies [89982ba]
+- Updated dependencies [6f5471b]
+- Updated dependencies [89982ba]
+- Updated dependencies [89982ba]
+  - @fabricorg/compiler@2.2.0
+  - @fabricorg/gen-capability@0.5.0
+  - @fabricorg/gen-conformance@0.3.0
+  - @fabricorg/gen-graphql@3.1.0
+  - @fabricorg/sdui-release@0.3.0
+  - @fabricorg/assembly@0.3.0
+
+## 0.4.0
+
+### Minor Changes
+
+- bd67ad6: Add non-destructive capability initialization and fail-closed application
+  composition checks for approved lockfiles, exact runtime artifacts, and
+  promoted experience releases.
+
+### Patch Changes
+
+- Updated dependencies [62dd1ca]
+- Updated dependencies [4e585a4]
+- Updated dependencies [b932767]
+- Updated dependencies [1ba3a9e]
+- Updated dependencies [8e9a571]
+- Updated dependencies [e6aede7]
+  - @fabricorg/assembly@0.2.0
+  - @fabricorg/gen-capability@0.4.1
+  - @fabricorg/sdui-release@0.2.0
+  - @fabricorg/compiler@2.1.1
+  - @fabricorg/gen-conformance@0.2.1
+  - @fabricorg/gen-graphql@3.0.1
+  - @fabricorg/gen-sdui@0.5.1
+
+### Additional release notes
+
+### Minor Changes
+
+- Add `init capability` for non-destructive compiler-valid scaffolding and
+  `check-application` for exact runtime capability, assembly lockfile, and
+  promoted experience release verification.
+
 ## 0.3.2
 
 ### Patch Changes
@@ -8,7 +139,7 @@
 - Updated dependencies [c504d0a]
   - @fabricorg/compiler@2.1.0
   - @fabricorg/gen-graphql@3.0.0
-  - @fabricorg/gen-conformance@1.0.0
+  - @fabricorg/gen-conformance@0.2.0
   - @fabricorg/gen-capability@0.4.0
 
 ## 0.3.1

package/README.md

@@ -1,6 +1,22 @@
 # `fabric-gen`
 
-Thin CLI over independently versioned Fabric generator targets.
+Scaffold capability source, run independently versioned generators, and verify
+an application composition before deployment.
+
+Create a compiler-valid capability without copying a repository template:
+
+```bash
+fabric-gen init capability case-review
+fabric-gen init experience portfolio --directory apps/saas/modules/portfolio
+fabric-gen init capability case-review --directory packages/case-review
+```
+
+`init experience` adds runtime, gateway, component-pack, and application-check
+integration files to an existing Supastarter-derived application. It never creates or
+replaces the application shell.
+
+Initialization refuses to overwrite either `README.md` or
+`fabric.manifest.json`.
 
 ```bash
 fabric-gen --input fabric-manifest.json --out generated
@@ -9,3 +25,27 @@ fabric-gen --input fabric-manifest.json --out generated --check
 
 `--check` performs no writes and fails for changed or stale artifacts. Generated files contain a
 manifest digest and generator version, never timestamps.
+
+Check the exact artifacts an application will load:
+
+```bash
+fabric-gen check-application --config fabric.application.json
+```
+
+`fabric.application.json` uses paths relative to itself:
+
+```json
+{
+  "formatVersion": 1,
+  "assembly": "./fabric.assembly.lock.json",
+  "runtimeCapabilities": "./fabric.runtime.json",
+  "releases": ["./releases/web.json"]
+}
+```
+
+The runtime file is an array of `{ "namespace", "version", "manifestDigest" }`
+objects derived from the modules actually registered by the application. The
+check verifies lockfile integrity, rejects missing, extra, duplicate, or
+mismatched runtime capabilities, verifies each promoted experience release,
+and requires every release to name the same assembly digest. It does not
+inspect caller assertions in place of runtime artifact metadata.

package/dist/chunk-4QFNFERM.js

@@ -0,0 +1,413 @@
+// index.ts
+import { access, mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { createPrivateKey } from "crypto";
+import path from "path";
+import { compileManifestBundle, runGenerator } from "@fabricorg/compiler";
+import { capabilityGenerator } from "@fabricorg/gen-capability";
+import { docsGenerator } from "@fabricorg/gen-docs";
+import { eventsGenerator } from "@fabricorg/gen-events";
+import { typesGenerator } from "@fabricorg/gen-types";
+import { prismaGenerator } from "@fabricorg/gen-prisma";
+import { graphqlGenerator } from "@fabricorg/gen-graphql";
+import { sduiGenerator } from "@fabricorg/gen-sdui";
+import { createEs256ReleaseSigner, promoteExperienceRelease } from "@fabricorg/sdui-composer";
+import { conformanceGenerator } from "@fabricorg/gen-conformance";
+import {
+  assertAssemblyLockfile,
+  assertAssemblyRuntimeCompatible
+} from "@fabricorg/assembly";
+import {
+  assertSduiReleaseIntegrity
+} from "@fabricorg/sdui-release";
+var GENERATOR_TARGETS = {
+  types: typesGenerator,
+  events: eventsGenerator,
+  capability: capabilityGenerator,
+  docs: docsGenerator,
+  prisma: prismaGenerator,
+  graphql: graphqlGenerator,
+  sdui: sduiGenerator,
+  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 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(args, flag) {
+  const index = args.indexOf(flag);
+  if (index < 0) return void 0;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new FabricGenUsageError(usage);
+  return value;
+}
+async function runFabricGenCommand(args) {
+  if (args[0] === "init") {
+    if (!args[2] || args[2].startsWith("--")) {
+      throw new FabricGenUsageError(usage);
+    }
+    const name = args[2];
+    const directory = flagValue(args, "--directory") ?? name;
+    if (args[1] === "capability") {
+      const result2 = await initializeCapability({ directory, namespace: name });
+      return `Initialized capability "${name}" with ${result2.created.length} files.`;
+    }
+    if (args[1] === "experience") {
+      const result2 = await initializeExperience({ directory, application: name });
+      return `Initialized experience integration "${name}" with ${result2.created.length} files.`;
+    }
+    throw new FabricGenUsageError(usage);
+  }
+  if (args[0] === "promote-experience") {
+    const configPath = flagValue(args, "--config");
+    const privateKeyPath = flagValue(args, "--key");
+    if (!configPath) throw new FabricGenUsageError("promote-experience requires --config.");
+    if (!privateKeyPath) throw new FabricGenUsageError("promote-experience requires --key.");
+    const outputPath = flagValue(args, "--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 (args[0] === "check-application") {
+    const configPath = flagValue(args, "--config") ?? "fabric.application.json";
+    const result2 = await checkApplication({ configPath });
+    return `Checked "${result2.application}": ${result2.capabilities} capabilities, ${result2.releases} releases.`;
+  }
+  const inputPath = flagValue(args, "--input");
+  const outputDirectory = flagValue(args, "--out");
+  if (!inputPath || !outputDirectory) throw new FabricGenUsageError(usage);
+  const result = await generateFromManifest({
+    inputPath,
+    outputDirectory,
+    targets: (flagValue(args, "--targets") ?? "types,events,capability,docs").split(",").filter(Boolean),
+    check: args.includes("--check")
+  });
+  return `${args.includes("--check") ? "Checked" : "Generated"} ${result.files.length} files.`;
+}
+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 = [
+    [
+      path.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")
+    ],
+    [
+      path.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")
+    ],
+    [
+      path.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)}
+`
+    ]
+  ];
+  await mkdir(options.directory, { recursive: true });
+  const created = [];
+  try {
+    for (const [file, content] of files) {
+      await writeFile(file, content, { encoding: "utf8", flag: "wx" });
+      created.push(file);
+    }
+  } catch (error) {
+    await Promise.all(created.map((file) => 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 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 = path.dirname(options.configPath);
+  const resolve = (file) => path.resolve(base, file);
+  const assembly = await readJson(resolve(configValue.assembly));
+  assertAssemblyLockfile(assembly);
+  const runtimeCapabilities = await readJson(
+    resolve(configValue.runtimeCapabilities)
+  );
+  if (!Array.isArray(runtimeCapabilities)) {
+    throw new Error("Runtime capabilities must be a JSON array.");
+  }
+  assertAssemblyRuntimeCompatible(assembly, runtimeCapabilities);
+  for (const releasePath of configValue.releases) {
+    const release = await readJson(resolve(releasePath));
+    try {
+      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 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 manifestPath = path.join(options.directory, "fabric.manifest.json");
+  const readmePath = path.join(options.directory, "README.md");
+  for (const file of [readmePath, manifestPath]) {
+    try {
+      await 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 manifest = {
+    manifestVersion: 2,
+    namespace: options.namespace,
+    objectTypes: [],
+    subjectTypes: [],
+    idPrefixes: [],
+    dependencies: [],
+    policies: [],
+    eventTypes: [],
+    actions: [],
+    views: [],
+    stateMachines: [],
+    capability: {
+      displayName,
+      description: `Governed ${displayName.toLowerCase()} capability.`,
+      stability: "experimental"
+    }
+  };
+  const readme = [
+    `# ${displayName}`,
+    "",
+    "Define domain objects, governed actions, events, and projections in `fabric.manifest.json`.",
+    "",
+    "```bash",
+    "fabric-gen --input fabric.manifest.json --out generated",
+    "fabric-gen --input fabric.manifest.json --out generated --check",
+    "```",
+    ""
+  ].join("\n");
+  await mkdir(options.directory, { recursive: true });
+  const created = [];
+  try {
+    for (const [file, content] of [
+      [readmePath, readme],
+      [manifestPath, `${JSON.stringify(manifest, null, 2)}
+`]
+    ]) {
+      await writeFile(file, content, { encoding: "utf8", flag: "wx" });
+      created.push(file);
+    }
+  } catch (error) {
+    await Promise.all(created.map((file) => rm(file, { force: true })));
+    if (error.code === "EEXIST") {
+      throw new Error("Refusing to overwrite a file created during capability initialization.");
+    }
+    throw error;
+  }
+  return { created };
+}
+async function generateFromManifest(options) {
+  const input = JSON.parse(await 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 = 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 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) => rm(path.join(options.outputDirectory, file), { force: true })));
+  const changed = [];
+  for (const file of files) {
+    const target = path.join(options.outputDirectory, file.path);
+    let current;
+    try {
+      current = await readFile(target, "utf8");
+    } catch {
+      current = void 0;
+    }
+    if (current !== file.content) {
+      changed.push(file.path);
+      if (!options.check) {
+        await mkdir(path.dirname(target), { recursive: true });
+        await 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 readdir(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const nested = await Promise.all(entries.map((entry) => entry.isDirectory() ? listFiles(path.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 = path.dirname(options.configPath);
+  const resolve = (file) => path.resolve(base, file);
+  const assembly = await readJson(resolve(configValue.assembly));
+  assertAssemblyLockfile(assembly);
+  const release = await readJson(resolve(configValue.release));
+  assertSduiReleaseIntegrity(release);
+  const contracts = await Promise.all(
+    configValue.contracts.map(async (file) => await readJson(resolve(file)))
+  );
+  const privateKey = createPrivateKey(await readFile(options.privateKeyPath, "utf8"));
+  const promoted = await promoteExperienceRelease({
+    application: configValue.application,
+    release,
+    contracts,
+    assembly,
+    issuer: configValue.issuer,
+    signer: createEs256ReleaseSigner({ keyId: configValue.keyId, privateKey })
+  });
+  const outputPath = options.outputPath ? path.resolve(options.outputPath) : resolve(`${configValue.application}.experience-release.jws`);
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await 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
+  };
+}
+
+export {
+  GENERATOR_TARGETS,
+  FabricGenUsageError,
+  fabricGenCliExitCode,
+  runFabricGenCommand,
+  initializeExperience,
+  checkApplication,
+  initializeCapability,
+  generateFromManifest,
+  promoteExperience
+};
+//# sourceMappingURL=chunk-4QFNFERM.js.map