@fabricorg/sdui-release 0.3.0

package/dist/index.cjs

@@ -0,0 +1,893 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  SDUI_COMPONENT_PACK_FORMAT_VERSION: () => SDUI_COMPONENT_PACK_FORMAT_VERSION,
+  SDUI_DOCUMENT_FORMAT_VERSION: () => SDUI_DOCUMENT_FORMAT_VERSION,
+  SDUI_DOCUMENT_JSON_SCHEMA: () => SDUI_DOCUMENT_JSON_SCHEMA,
+  SDUI_RELEASE_FORMAT_VERSION: () => SDUI_RELEASE_FORMAT_VERSION,
+  SDUI_RELEASE_JSON_SCHEMA: () => SDUI_RELEASE_JSON_SCHEMA,
+  SDUI_TOKEN_SET_FORMAT_VERSION: () => SDUI_TOKEN_SET_FORMAT_VERSION,
+  assertSduiAuthorizationGrants: () => assertSduiAuthorizationGrants,
+  assertSduiComponentPack: () => assertSduiComponentPack,
+  assertSduiDocument: () => assertSduiDocument,
+  assertSduiFragment: () => assertSduiFragment,
+  assertSduiRelease: () => assertSduiRelease,
+  assertSduiReleaseIntegrity: () => assertSduiReleaseIntegrity,
+  assertSduiReleaseValid: () => assertSduiReleaseValid,
+  assertSduiTokenSet: () => assertSduiTokenSet,
+  computeReleaseDigest: () => computeReleaseDigest,
+  createSduiChannel: () => createSduiChannel,
+  validateSduiRelease: () => validateSduiRelease
+});
+module.exports = __toCommonJS(index_exports);
+
+// types.ts
+var SDUI_DOCUMENT_FORMAT_VERSION = 1;
+var SDUI_TOKEN_SET_FORMAT_VERSION = 1;
+var SDUI_COMPONENT_PACK_FORMAT_VERSION = 1;
+var SDUI_RELEASE_FORMAT_VERSION = 2;
+
+// structural.ts
+var import_platform = require("@fabricorg/platform");
+var import_assembly = require("@fabricorg/assembly");
+
+// helpers.ts
+function fail(path, message) {
+  throw new Error(`SDUI ${path} ${message}.`);
+}
+function requireString(value, path) {
+  if (typeof value !== "string" || !value.trim()) fail(path, "must be a non-empty string");
+  return value;
+}
+function requireRecord(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) fail(path, "must be an object");
+  return value;
+}
+function requireArray(value, path) {
+  if (!Array.isArray(value)) fail(path, "must be an array");
+  return value;
+}
+function parseCapabilityRef(ref) {
+  const match = /^capability:\/\/([a-z][a-z0-9-]*)\/(.+)$/.exec(ref);
+  if (!match) return void 0;
+  return { namespace: match[1], name: match[2] };
+}
+
+// structural.ts
+var TOKEN_TYPES = /* @__PURE__ */ new Set(["color", "spacing", "fontSize", "fontWeight", "radius", "border", "shadow"]);
+function assertSduiTokenSet(value, path = "tokenSet") {
+  const tokenSet = requireRecord(value, path);
+  if (tokenSet.formatVersion !== 1) {
+    fail(`${path}.formatVersion`, `must be 1, received ${JSON.stringify(tokenSet.formatVersion)}`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(requireString(tokenSet.name, `${path}.name`))) {
+    fail(`${path}.name`, "must be lowercase letters, numbers and hyphens");
+  }
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(requireString(tokenSet.version, `${path}.version`))) {
+    fail(`${path}.version`, "must be a semver version");
+  }
+  const tokens = requireRecord(tokenSet.tokens, `${path}.tokens`);
+  for (const [name, token] of Object.entries(tokens)) {
+    const tokenPath = `${path}.tokens.${name}`;
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) fail(tokenPath, "token name must be lowercase letters, numbers and hyphens");
+    const entry = requireRecord(token, tokenPath);
+    const type = requireString(entry.type, `${tokenPath}.type`);
+    if (!TOKEN_TYPES.has(type)) fail(`${tokenPath}.type`, `must be one of ${[...TOKEN_TYPES].join(", ")}`);
+    requireString(entry.value, `${tokenPath}.value`);
+  }
+}
+function assertSduiComponentPack(value, path = "componentPack") {
+  const pack = requireRecord(value, path);
+  if (pack.formatVersion !== 1) {
+    fail(`${path}.formatVersion`, `must be 1, received ${JSON.stringify(pack.formatVersion)}`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(requireString(pack.pack, `${path}.pack`))) {
+    fail(`${path}.pack`, "must be lowercase letters, numbers and hyphens");
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(requireString(pack.namespace, `${path}.namespace`))) {
+    fail(`${path}.namespace`, "must be lowercase letters, numbers and hyphens");
+  }
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(requireString(pack.version, `${path}.version`))) {
+    fail(`${path}.version`, "must be a semver version");
+  }
+  if (!/^[0-9a-f]{64}$/.test(requireString(pack.artifactDigest, `${path}.artifactDigest`))) {
+    fail(`${path}.artifactDigest`, "must be a lowercase SHA-256 digest");
+  }
+  if (pack.remote !== void 0) {
+    const remote = requireRecord(pack.remote, `${path}.remote`);
+    requireString(remote.entry, `${path}.remote.entry`);
+    if (!/^sha(256|384|512)-[A-Za-z0-9+/]+={0,2}$/.test(requireString(remote.integrity, `${path}.remote.integrity`))) {
+      fail(`${path}.remote.integrity`, 'must be a subresource-integrity value, e.g. "sha384-\u2026"');
+    }
+    const exposes = requireRecord(remote.exposes, `${path}.remote.exposes`);
+    for (const [component, modulePath] of Object.entries(exposes)) {
+      requireString(modulePath, `${path}.remote.exposes.${component}`);
+    }
+  }
+  const components = requireRecord(pack.components, `${path}.components`);
+  for (const [name, definition] of Object.entries(components)) {
+    const componentPath = `${path}.components.${name}`;
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) fail(componentPath, "component name must be lowercase letters, numbers and hyphens");
+    const def = requireRecord(definition, componentPath);
+    if (def.implements !== void 0) {
+      if (!Array.isArray(def.implements)) fail(`${componentPath}.implements`, "must be an array");
+      for (const impl of def.implements) {
+        if (typeof impl !== "string" || !impl.trim()) fail(`${componentPath}.implements`, "entries must be non-empty strings");
+      }
+    }
+    if (def.propsSchema !== void 0) {
+      try {
+        (0, import_platform.assertPortableJsonSchema)(def.propsSchema, `${componentPath}.propsSchema`);
+      } catch (error) {
+        fail(componentPath, error instanceof Error ? error.message : String(error));
+      }
+    }
+    if (def.slots !== void 0) {
+      if (!Array.isArray(def.slots)) fail(`${componentPath}.slots`, "must be an array");
+      for (const slot of def.slots) {
+        if (typeof slot !== "string" || !/^[a-z][a-z0-9-]*$/.test(slot)) fail(`${componentPath}.slots`, "slot names must be lowercase letters, numbers and hyphens");
+      }
+    }
+  }
+}
+function assertSduiFragment(value, path = "fragment") {
+  const fragment = requireRecord(value, path);
+  requireString(fragment.id, `${path}.id`);
+  if (fragment.component !== void 0) requireString(fragment.component, `${path}.component`);
+  if (fragment.slot !== void 0) {
+    if (!/^[a-z][a-z0-9-]*$/.test(requireString(fragment.slot, `${path}.slot`))) {
+      fail(`${path}.slot`, "must be lowercase letters, numbers and hyphens");
+    }
+  }
+  if (fragment.dataRef !== void 0) {
+    const dataRef = requireString(fragment.dataRef, `${path}.dataRef`);
+    if (!dataRef.startsWith("capability://")) fail(`${path}.dataRef`, "must be a capability:// reference");
+  }
+  if (fragment.props !== void 0) {
+    requireRecord(fragment.props, `${path}.props`);
+  }
+  if (fragment.actions !== void 0) {
+    const actions = requireRecord(fragment.actions, `${path}.actions`);
+    for (const [name, ref] of Object.entries(actions)) {
+      const actionPath = `${path}.actions.${name}`;
+      const actionRef = requireRecord(ref, actionPath);
+      requireString(actionRef.intent, `${actionPath}.intent`);
+    }
+  }
+  if (fragment.children !== void 0) {
+    const children = requireArray(fragment.children, `${path}.children`);
+    children.forEach((child, index) => assertSduiFragment(child, `${path}.children[${index}]`));
+  }
+}
+function assertSduiDocument(value, path = "document") {
+  const document = requireRecord(value, path);
+  if (document.formatVersion !== 1) {
+    fail(`${path}.formatVersion`, `must be 1, received ${JSON.stringify(document.formatVersion)}`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(requireString(document.name, `${path}.name`))) {
+    fail(`${path}.name`, "must be lowercase letters, numbers and hyphens");
+  }
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(requireString(document.version, `${path}.version`))) {
+    fail(`${path}.version`, "must be a semver version");
+  }
+  assertSduiFragment(document.root, `${path}.root`);
+  if (document.variants !== void 0) {
+    requireArray(document.variants, `${path}.variants`).forEach((entry, index) => {
+      const variantPath = `${path}.variants[${index}]`;
+      const variant = requireRecord(entry, variantPath);
+      if (!/^[a-z][a-z0-9-]*$/.test(requireString(variant.id, `${variantPath}.id`))) {
+        fail(`${variantPath}.id`, "must be lowercase letters, numbers and hyphens");
+      }
+      if (variant.description !== void 0) requireString(variant.description, `${variantPath}.description`);
+      assertSduiFragment(variant.root, `${variantPath}.root`);
+    });
+  }
+  const tokenSet = requireRecord(document.tokenSet, `${path}.tokenSet`);
+  requireString(tokenSet.name, `${path}.tokenSet.name`);
+  requireString(tokenSet.version, `${path}.tokenSet.version`);
+  requireArray(document.componentPacks, `${path}.componentPacks`).forEach((entry, index) => {
+    const pack = requireRecord(entry, `${path}.componentPacks[${index}]`);
+    requireString(pack.pack, `${path}.componentPacks[${index}].pack`);
+    requireString(pack.namespace, `${path}.componentPacks[${index}].namespace`);
+    requireString(pack.range, `${path}.componentPacks[${index}].range`);
+  });
+}
+function assertSduiAuthorizationGrants(value, path = "grants") {
+  const grants = requireRecord(value, path);
+  const views = requireArray(grants.views, `${path}.views`);
+  const intents = requireArray(grants.intents, `${path}.intents`);
+  for (const [index, reference] of views.entries()) {
+    const referencePath = `${path}.views[${index}]`;
+    if (!parseCapabilityRef(requireString(reference, referencePath))) {
+      fail(referencePath, "must be a valid capability:// reference");
+    }
+  }
+  for (const [index, reference] of intents.entries()) {
+    const referencePath = `${path}.intents[${index}]`;
+    if (!parseCapabilityRef(requireString(reference, referencePath))) {
+      fail(referencePath, "must be a valid capability:// reference");
+    }
+  }
+  if (grants.fragments !== void 0) {
+    const fragments = requireRecord(grants.fragments, `${path}.fragments`);
+    const prototype = Object.getPrototypeOf(fragments);
+    if (prototype !== Object.prototype && prototype !== null) {
+      fail(`${path}.fragments`, "must be a plain object; a fragment grant assigned through __proto__ would be silently discarded");
+    }
+    for (const [fragmentId, declared] of Object.entries(fragments)) {
+      const fragmentPath = `${path}.fragments.${fragmentId}`;
+      const scoped = requireRecord(declared, fragmentPath);
+      for (const field of ["views", "intents"]) {
+        if (scoped[field] === void 0) continue;
+        requireArray(scoped[field], `${fragmentPath}.${field}`).forEach((reference, index) => {
+          const referencePath = `${fragmentPath}.${field}[${index}]`;
+          if (!parseCapabilityRef(requireString(reference, referencePath))) {
+            fail(referencePath, "must be a valid capability:// reference");
+          }
+        });
+      }
+    }
+  }
+}
+function assertSduiRelease(value, path = "release") {
+  const release = requireRecord(value, path);
+  if (release.formatVersion !== 2) {
+    fail(`${path}.formatVersion`, `must be 2, received ${JSON.stringify(release.formatVersion)}`);
+  }
+  for (const field of ["releaseDigest", "assemblyDigest"]) {
+    if (!/^[0-9a-f]{64}$/.test(requireString(release[field], `${path}.${field}`))) {
+      fail(`${path}.${field}`, "must be a lowercase SHA-256 digest");
+    }
+  }
+  assertSduiDocument(release.document, `${path}.document`);
+  assertSduiTokenSet(release.tokenSet, `${path}.tokenSet`);
+  assertSduiAuthorizationGrants(release.grants, `${path}.grants`);
+  requireArray(release.componentPacks, `${path}.componentPacks`).forEach((value2, index) => {
+    const packPath = `${path}.componentPacks[${index}]`;
+    const pack = requireRecord(value2, packPath);
+    for (const field of ["pack", "namespace"]) {
+      if (!/^[a-z][a-z0-9-]*$/.test(requireString(pack[field], `${packPath}.${field}`))) {
+        fail(`${packPath}.${field}`, "must be lowercase letters, numbers and hyphens");
+      }
+    }
+    if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(
+      requireString(pack.version, `${packPath}.version`)
+    )) {
+      fail(`${packPath}.version`, "must be a semver version");
+    }
+    const range = requireString(pack.range, `${packPath}.range`);
+    if (!(0, import_assembly.parseSemverRange)(range)) {
+      fail(`${packPath}.range`, "must be a supported semver range");
+    }
+    if (!/^[0-9a-f]{64}$/.test(requireString(pack.artifactDigest, `${packPath}.artifactDigest`))) {
+      fail(`${packPath}.artifactDigest`, "must be a lowercase SHA-256 digest");
+    }
+  });
+}
+
+// validate.ts
+var import_assembly2 = require("@fabricorg/assembly");
+var import_gen_capability = require("@fabricorg/gen-capability");
+
+// digest.ts
+var import_node_crypto = require("crypto");
+function sortJson(value) {
+  if (Array.isArray(value)) return value.map(sortJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, sortJson(child)])
+    );
+  }
+  return value;
+}
+function stableStringify(value) {
+  return JSON.stringify(sortJson(value));
+}
+function canonicalFragmentGrants(fragments) {
+  if (!fragments) return {};
+  return Object.fromEntries(
+    Object.keys(fragments).sort().map((fragmentId) => {
+      const declared = fragments[fragmentId];
+      return [fragmentId, {
+        ...declared.views ? { views: [...declared.views].sort() } : {},
+        ...declared.intents ? { intents: [...declared.intents].sort() } : {}
+      }];
+    })
+  );
+}
+function releaseDigest(document, tokenSet, componentPacks, grants, assemblyDigest) {
+  const canonical = stableStringify({
+    document: {
+      formatVersion: document.formatVersion,
+      name: document.name,
+      version: document.version,
+      root: document.root,
+      // Selectable trees, so two documents differing only in their variants
+      // must not share a digest. Sorted by id, because reordering the same
+      // set does not change which trees can render. Omitted entirely when
+      // absent, so a document that declares none digests exactly as it did
+      // before variants existed.
+      ...document.variants?.length ? {
+        variants: [...document.variants].sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0)
+      } : {},
+      tokenSet: document.tokenSet,
+      componentPacks: [...document.componentPacks].sort((a, b) => {
+        const key = (e) => `${e.namespace}/${e.pack}`;
+        return key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0;
+      })
+    },
+    tokenSet: {
+      formatVersion: tokenSet.formatVersion,
+      name: tokenSet.name,
+      version: tokenSet.version,
+      tokens: tokenSet.tokens
+    },
+    componentPacks: [...componentPacks].sort((a, b) => {
+      const key = (e) => `${e.namespace}/${e.pack}`;
+      return key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0;
+    }),
+    grants: {
+      views: [...grants.views].sort(),
+      intents: [...grants.intents].sort(),
+      // Omitted when absent for the same reason as variants: a release with
+      // no per-fragment narrowing must digest as it did before the field
+      // existed, or every previously promoted release stops verifying.
+      ...grants.fragments && Object.keys(grants.fragments).length ? { fragments: canonicalFragmentGrants(grants.fragments) } : {}
+    },
+    assemblyDigest
+  });
+  return (0, import_node_crypto.createHash)("sha256").update(canonical).digest("hex");
+}
+function computeReleaseDigest(document, tokenSet, componentPacks, grants, assemblyDigest) {
+  return releaseDigest(document, tokenSet, componentPacks, grants, assemblyDigest);
+}
+function assertSduiReleaseIntegrity(release) {
+  assertSduiRelease(release);
+  const expected = releaseDigest(
+    release.document,
+    release.tokenSet,
+    release.componentPacks,
+    release.grants,
+    release.assemblyDigest
+  );
+  if (release.releaseDigest !== expected) {
+    throw new Error(`SDUI release releaseDigest does not match promoted content; expected "${expected}".`);
+  }
+}
+
+// capabilities.ts
+function buildKnownViews(contracts) {
+  const views = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    for (const view of contract.views) {
+      const name = view.name.startsWith(`${contract.namespace}/`) ? view.name.slice(contract.namespace.length + 1) : view.name;
+      views.add(`${contract.namespace}/${name}`);
+    }
+  }
+  return views;
+}
+function buildKnownActionIntents(contracts) {
+  const intents = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    const experience = contract.extensions?.["fabric.experience/v1"];
+    for (const intent of experience?.actionIntents ?? []) {
+      const shortName = intent.name.startsWith(`${contract.namespace}.`) ? intent.name.slice(contract.namespace.length + 1) : intent.name;
+      intents.add(`${contract.namespace}/${shortName}`);
+    }
+  }
+  return intents;
+}
+function buildGrantedReferences(references, path) {
+  const granted = /* @__PURE__ */ new Set();
+  for (const [index, reference] of references.entries()) {
+    const referencePath = `${path}[${index}]`;
+    if (!parseCapabilityRef(reference)) {
+      fail(referencePath, "must be a valid capability:// reference");
+    }
+    granted.add(reference);
+  }
+  return granted;
+}
+function validateIntentActionDeclarations(contracts, add) {
+  for (const contract of contracts) {
+    const experience = contract.extensions?.["fabric.experience/v1"];
+    const actions = new Set(contract.actions.map((action) => action.actionId));
+    for (const [index, intent] of (experience?.actionIntents ?? []).entries()) {
+      if (!actions.has(intent.actionId)) {
+        add(
+          "intent_action_not_found",
+          `contracts.${contract.namespace}.actionIntents[${index}].actionId`,
+          `intent "${intent.name}" references action "${intent.actionId}", which the capability does not declare`
+        );
+      }
+    }
+  }
+}
+
+// walker.ts
+var MAX_PROP_DEPTH = 64;
+function isCapabilityRefValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.$ref === "string" && value.$ref.startsWith("capability://");
+}
+function narrowGrants(current, declared) {
+  if (declared === void 0) return current;
+  return new Set(declared.filter((reference) => current.has(reference)));
+}
+function walkFragment(fragment, path, context) {
+  const declared = context.fragmentGrants?.get(fragment.id);
+  const scoped = declared ? {
+    ...context,
+    grantedViews: narrowGrants(context.grantedViews, declared.views),
+    grantedIntents: narrowGrants(context.grantedIntents, declared.intents)
+  } : context;
+  if (scoped.ids.has(fragment.id)) {
+    scoped.add("duplicate_fragment_id", `${path}.id`, `fragment id "${fragment.id}" is declared more than once`);
+  } else {
+    scoped.ids.add(fragment.id);
+  }
+  if (fragment.component !== void 0) {
+    const separator = fragment.component.indexOf(".");
+    if (separator === -1) {
+      if (!scoped.coreComponents.has(fragment.component)) {
+        scoped.add(
+          "unknown_component",
+          `${path}.component`,
+          `component "${fragment.component}" is not a core component or in any declared pack`
+        );
+      }
+    } else if (!scoped.knownComponents.has(fragment.component)) {
+      scoped.add(
+        "unknown_component",
+        `${path}.component`,
+        `component "${fragment.component}" is not in any declared component pack`
+      );
+    }
+  }
+  if (fragment.dataRef !== void 0) {
+    const ref = parseCapabilityRef(fragment.dataRef);
+    if (!ref) {
+      scoped.add(
+        "unauthorized_data_ref",
+        `${path}.dataRef`,
+        `"${fragment.dataRef}" is not a valid capability:// view reference`
+      );
+    } else if (!scoped.knownViews.has(`${ref.namespace}/${ref.name}`)) {
+      scoped.add(
+        "unauthorized_data_ref",
+        `${path}.dataRef`,
+        `fragment references view "${fragment.dataRef}" which no known capability publishes`
+      );
+    } else if (!scoped.grantedViews.has(fragment.dataRef)) {
+      scoped.add(
+        "denied_view_ref",
+        `${path}.dataRef`,
+        `fragment references view "${fragment.dataRef}" which is published but not granted to this release`
+      );
+    }
+  }
+  for (const [name, actionRef] of Object.entries(fragment.actions ?? {})) {
+    const actionPath = `${path}.actions.${name}`;
+    const ref = parseCapabilityRef(actionRef.intent);
+    if (!ref) {
+      scoped.add(
+        "mutation_bypass",
+        `${actionPath}.intent`,
+        `action "${name}" intent "${actionRef.intent}" is not a capability:// reference; direct mutations bypass governance`
+      );
+      continue;
+    }
+    if (!scoped.knownIntents.has(`${ref.namespace}/${ref.name}`)) {
+      scoped.add(
+        "mutation_bypass",
+        `${actionPath}.intent`,
+        `action "${name}" references intent "${actionRef.intent}" which no known capability declares`
+      );
+    } else if (!scoped.grantedIntents.has(actionRef.intent)) {
+      scoped.add(
+        "denied_intent_ref",
+        `${actionPath}.intent`,
+        `action "${name}" references intent "${actionRef.intent}" which is published but not granted to this release`
+      );
+    }
+    if (actionRef.params !== void 0) {
+      checkPropValues(actionRef.params, `${actionPath}.params`, scoped);
+    }
+  }
+  if (fragment.props !== void 0) {
+    checkPropValues(fragment.props, `${path}.props`, scoped);
+  }
+  if (fragment.children !== void 0) {
+    fragment.children.forEach((child, index) => {
+      walkFragment(child, `${path}.children[${index}]`, scoped);
+    });
+  }
+}
+function checkValue(value, path, context, depth = 0) {
+  if (depth > MAX_PROP_DEPTH) {
+    context.add(
+      "invalid_fragment",
+      path,
+      `prop nesting exceeds ${MAX_PROP_DEPTH} levels; a cyclic or pathologically deep value cannot be checked`
+    );
+    return;
+  }
+  if (isCapabilityRefValue(value)) {
+    const ref = parseCapabilityRef(value.$ref);
+    if (!ref) {
+      context.add(
+        "unauthorized_data_ref",
+        `${path}.$ref`,
+        `"${value.$ref}" is not a valid capability:// view reference`
+      );
+    } else if (!context.knownViews.has(`${ref.namespace}/${ref.name}`)) {
+      context.add(
+        "unauthorized_data_ref",
+        `${path}.$ref`,
+        `prop references view "${value.$ref}" which no known capability publishes`
+      );
+    } else if (!context.grantedViews.has(value.$ref)) {
+      context.add(
+        "denied_view_ref",
+        `${path}.$ref`,
+        `prop references view "${value.$ref}" which is published but not granted to this release`
+      );
+    }
+    for (const [key, sibling] of Object.entries(value)) {
+      if (key === "$ref") continue;
+      checkValue(sibling, `${path}.${key}`, context, depth + 1);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => checkValue(item, `${path}[${index}]`, context, depth + 1));
+    return;
+  }
+  if (value !== null && typeof value === "object") {
+    checkPropValues(value, path, context, depth + 1);
+  }
+}
+function checkPropValues(props, path, context, depth = 0) {
+  for (const [key, value] of Object.entries(props)) {
+    checkValue(value, `${path}.${key}`, context, depth);
+  }
+}
+
+// validate.ts
+function validateSduiRelease(input) {
+  if (!input.assembly) throw new Error("An approved assembly lockfile is required for every SDUI release.");
+  assertSduiDocument(input.document);
+  assertSduiTokenSet(input.tokenSet);
+  for (const pack of input.componentPacks) assertSduiComponentPack(pack);
+  for (const contract of input.contracts) (0, import_gen_capability.assertUsageContractDocument)(contract);
+  assertSduiAuthorizationGrants(input.grants);
+  (0, import_assembly2.assertAssemblyLockfile)(input.assembly);
+  const contracts = input.contracts.map((document) => document.capability);
+  const findings = [];
+  const add = (code, path, message) => {
+    findings.push({ code, path, message });
+  };
+  if (input.document.tokenSet.name !== input.tokenSet.name) {
+    add(
+      "missing_token_set",
+      "document.tokenSet.name",
+      `document references token set "${input.document.tokenSet.name}" but the provided set is "${input.tokenSet.name}"`
+    );
+  }
+  if (input.document.tokenSet.version !== input.tokenSet.version) {
+    add(
+      "missing_token_set",
+      "document.tokenSet.version",
+      `document references token set version "${input.document.tokenSet.version}" but the provided set is version "${input.tokenSet.version}"`
+    );
+  }
+  const packsByKey = /* @__PURE__ */ new Map();
+  for (const pack of input.componentPacks) {
+    const key = `${pack.namespace}/${pack.pack}`;
+    const list = packsByKey.get(key) ?? [];
+    list.push(pack);
+    packsByKey.set(key, list);
+  }
+  const resolvedPacks = [];
+  const resolvedPackDefinitions = [];
+  for (const ref of input.document.componentPacks) {
+    const key = `${ref.namespace}/${ref.pack}`;
+    const available = packsByKey.get(key) ?? [];
+    const range = (0, import_assembly2.parseSemverRange)(ref.range);
+    if (!range) {
+      add(
+        "incompatible_pack",
+        `document.componentPacks.${key}`,
+        `no available version of pack "${key}" satisfies range "${ref.range}"`
+      );
+      continue;
+    }
+    const resolvedVersion = (0, import_assembly2.resolveVersionRange)(range, available.map((pack) => pack.version));
+    if (!resolvedVersion) {
+      add(
+        "incompatible_pack",
+        `document.componentPacks.${key}`,
+        `no available version of pack "${key}" satisfies range "${ref.range}"`
+      );
+      continue;
+    }
+    const resolved = available.find((pack) => pack.version === resolvedVersion);
+    resolvedPackDefinitions.push(resolved);
+    resolvedPacks.push({
+      pack: resolved.pack,
+      namespace: resolved.namespace,
+      version: resolved.version,
+      range: ref.range,
+      artifactDigest: resolved.artifactDigest,
+      ...resolved.remote ? { remote: resolved.remote } : {}
+    });
+  }
+  {
+    for (const pack of resolvedPacks) {
+      const approved = input.assembly.componentPacks.find(
+        (candidate) => candidate.namespace === pack.namespace && candidate.pack === pack.pack && candidate.version === pack.version && candidate.artifactDigest === pack.artifactDigest
+      );
+      if (!approved) {
+        add(
+          "component_pack_not_in_assembly",
+          `componentPacks.${pack.namespace}/${pack.pack}`,
+          `pack "${pack.namespace}/${pack.pack}@${pack.version}" with artifact digest "${pack.artifactDigest}" is not in assembly "${input.assembly.assemblyDigest}"`
+        );
+        continue;
+      }
+      const declaredRemote = resolvedPackDefinitions.find((definition) => definition.namespace === pack.namespace && definition.pack === pack.pack && definition.version === pack.version && definition.artifactDigest === pack.artifactDigest)?.remote;
+      const remotePath = `componentPacks.${pack.namespace}/${pack.pack}.remote`;
+      if (declaredRemote && !approved.remote) {
+        add(
+          "remote_not_locked",
+          remotePath,
+          `pack "${pack.namespace}/${pack.pack}" is delivered as a federated remote, which assembly "${input.assembly.assemblyDigest}" has not locked`
+        );
+      } else if (declaredRemote && approved.remote) {
+        if (declaredRemote.entry !== approved.remote.entry) {
+          add(
+            "remote_not_locked",
+            `${remotePath}.entry`,
+            `remote entry "${declaredRemote.entry}" does not match the locked entry "${approved.remote.entry}"`
+          );
+        }
+        if (declaredRemote.integrity !== approved.remote.integrity) {
+          add(
+            "remote_not_locked",
+            `${remotePath}.integrity`,
+            `remote integrity "${declaredRemote.integrity}" does not match the locked integrity "${approved.remote.integrity}"`
+          );
+        }
+        if (canonicalExposes(declaredRemote.exposes) !== canonicalExposes(approved.remote.exposes)) {
+          add(
+            "remote_not_locked",
+            `${remotePath}.exposes`,
+            "remote exposed modules do not match the locked mapping"
+          );
+        }
+      } else if (!declaredRemote && approved.remote) {
+        add(
+          "remote_not_locked",
+          remotePath,
+          `assembly "${input.assembly.assemblyDigest}" locks a federated remote for "${pack.namespace}/${pack.pack}", but the supplied pack declares none`
+        );
+      }
+    }
+    for (const document of input.contracts) {
+      const approved = input.assembly.capabilities.find(
+        (capability) => capability.namespace === document.capability.namespace && capability.usageContractDigest === (0, import_assembly2.computeUsageContractDocumentDigest)(document)
+      );
+      if (!approved) {
+        add(
+          "capability_contract_not_in_assembly",
+          `contracts.${document.capability.namespace}`,
+          `contract "${document.capability.namespace}" is not the generated usage-contract document approved by assembly "${input.assembly.assemblyDigest}"`
+        );
+      }
+    }
+  }
+  const knownComponents = /* @__PURE__ */ new Set();
+  for (const pack of resolvedPackDefinitions) {
+    for (const name of Object.keys(pack.components)) {
+      knownComponents.add(`${pack.namespace}.${name}`);
+    }
+  }
+  const coreComponents = new Set(input.coreComponents ?? []);
+  const knownViews = buildKnownViews(contracts);
+  const knownIntents = buildKnownActionIntents(contracts);
+  const grantedViews = buildGrantedReferences(input.grants.views, "grants.views");
+  const grantedIntents = buildGrantedReferences(input.grants.intents, "grants.intents");
+  validateIntentActionDeclarations(contracts, add);
+  const fragmentGrants = /* @__PURE__ */ new Map();
+  for (const [fragmentId, declared] of Object.entries(input.grants.fragments ?? {})) {
+    for (const view of declared.views ?? []) {
+      if (!grantedViews.has(view)) {
+        add(
+          "fragment_grant_exceeds_release",
+          `grants.fragments.${fragmentId}.views`,
+          `fragment "${fragmentId}" is granted view "${view}", which the release itself does not grant`
+        );
+      }
+    }
+    for (const intent of declared.intents ?? []) {
+      if (!grantedIntents.has(intent)) {
+        add(
+          "fragment_grant_exceeds_release",
+          `grants.fragments.${fragmentId}.intents`,
+          `fragment "${fragmentId}" is granted intent "${intent}", which the release itself does not grant`
+        );
+      }
+    }
+    fragmentGrants.set(fragmentId, declared);
+  }
+  const walkTree = (root, path) => {
+    walkFragment(root, path, {
+      ids: /* @__PURE__ */ new Set(),
+      knownComponents,
+      knownViews,
+      grantedViews,
+      knownIntents,
+      grantedIntents,
+      fragmentGrants,
+      coreComponents,
+      findings,
+      add
+    });
+  };
+  walkTree(input.document.root, "document.root");
+  const seenVariantIds = /* @__PURE__ */ new Set();
+  (input.document.variants ?? []).forEach((variant, index) => {
+    if (seenVariantIds.has(variant.id)) {
+      add(
+        "duplicate_variant_id",
+        `document.variants[${index}].id`,
+        `variant id "${variant.id}" is declared more than once`
+      );
+    } else {
+      seenVariantIds.add(variant.id);
+    }
+    walkTree(variant.root, `document.variants[${index}].root`);
+  });
+  if (findings.length > 0) {
+    return { valid: false, findings, release: void 0 };
+  }
+  const release = {
+    formatVersion: 2,
+    releaseDigest: releaseDigest(
+      input.document,
+      input.tokenSet,
+      resolvedPacks,
+      input.grants,
+      input.assembly.assemblyDigest
+    ),
+    assemblyDigest: input.assembly.assemblyDigest,
+    document: input.document,
+    tokenSet: input.tokenSet,
+    componentPacks: [...resolvedPacks].sort((a, b) => {
+      const key = (e) => `${e.namespace}/${e.pack}`;
+      return key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0;
+    }),
+    grants: {
+      views: [...input.grants.views].sort(),
+      intents: [...input.grants.intents].sort(),
+      ...input.grants.fragments ? { fragments: canonicalFragmentGrants(input.grants.fragments) } : {}
+    }
+  };
+  return { valid: true, findings: [], release };
+}
+function assertSduiReleaseValid(input) {
+  const result = validateSduiRelease(input);
+  if (result.valid) return result.release;
+  throw new Error([
+    `SDUI release "${input.document.name}@${input.document.version}" is not valid:`,
+    ...result.findings.map((finding) => `  - [${finding.code}] ${finding.path}: ${finding.message}`)
+  ].join("\n"));
+}
+function canonicalExposes(exposes) {
+  return JSON.stringify(
+    Object.keys(exposes).sort().map((component) => [component, exposes[component]])
+  );
+}
+
+// channel.ts
+function createSduiChannel(id, coreComponents) {
+  return {
+    id,
+    coreComponents,
+    consume(release) {
+      assertSduiReleaseIntegrity(release);
+      const used = collectCoreComponents(release.document.root);
+      for (const variant of release.document.variants ?? []) {
+        for (const component of collectCoreComponents(variant.root)) used.add(component);
+      }
+      const missing = [...used].filter((component) => !coreComponents.includes(component));
+      return {
+        release,
+        compatible: missing.length === 0,
+        missingCoreComponents: missing
+      };
+    }
+  };
+}
+function collectCoreComponents(fragment) {
+  const used = /* @__PURE__ */ new Set();
+  if (fragment.component !== void 0 && !fragment.component.includes(".")) {
+    used.add(fragment.component);
+  }
+  if (fragment.children !== void 0) {
+    for (const child of fragment.children) {
+      for (const component of collectCoreComponents(child)) used.add(component);
+    }
+  }
+  return used;
+}
+
+// schemas.ts
+var SDUI_DOCUMENT_JSON_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "Fabric SDUI document",
+  type: "object",
+  required: ["formatVersion", "name", "version", "root", "tokenSet", "componentPacks"],
+  properties: {
+    formatVersion: { type: "integer", enum: [1] },
+    name: { type: "string", pattern: "^[a-z][a-z0-9-]*$" },
+    version: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+" },
+    root: { type: "object" },
+    tokenSet: { type: "object", required: ["name", "version"] },
+    componentPacks: { type: "array" }
+  }
+};
+var SDUI_RELEASE_JSON_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  title: "Fabric SDUI promoted release",
+  type: "object",
+  required: ["formatVersion", "releaseDigest", "assemblyDigest", "document", "tokenSet", "componentPacks", "grants"],
+  properties: {
+    formatVersion: { type: "integer", enum: [2] },
+    releaseDigest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+    assemblyDigest: { type: "string", pattern: "^[0-9a-f]{64}$" },
+    document: { type: "object" },
+    tokenSet: { type: "object" },
+    componentPacks: { type: "array" },
+    grants: { type: "object", required: ["views", "intents"] }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SDUI_COMPONENT_PACK_FORMAT_VERSION,
+  SDUI_DOCUMENT_FORMAT_VERSION,
+  SDUI_DOCUMENT_JSON_SCHEMA,
+  SDUI_RELEASE_FORMAT_VERSION,
+  SDUI_RELEASE_JSON_SCHEMA,
+  SDUI_TOKEN_SET_FORMAT_VERSION,
+  assertSduiAuthorizationGrants,
+  assertSduiComponentPack,
+  assertSduiDocument,
+  assertSduiFragment,
+  assertSduiRelease,
+  assertSduiReleaseIntegrity,
+  assertSduiReleaseValid,
+  assertSduiTokenSet,
+  computeReleaseDigest,
+  createSduiChannel,
+  validateSduiRelease
+});
+//# sourceMappingURL=index.cjs.map