@fabricorg/ports 0.2.0 → 0.4.0

package/dist/chunk-FH6OL7JX.js

@@ -0,0 +1,657 @@
+// index.ts
+var ALIAS = /^\{([^}]+)\}$/;
+var isToken = (value) => !!value && typeof value === "object" && !Array.isArray(value) && "$value" in value;
+var isGroup = (value) => !!value && typeof value === "object" && !Array.isArray(value) && !("$value" in value);
+function resolveDesignTokens(document) {
+  const flat = /* @__PURE__ */ new Map();
+  const walk = (node, path, inheritedType) => {
+    const groupType = typeof node.$type === "string" ? node.$type : inheritedType;
+    for (const [key, member] of Object.entries(node)) {
+      if (key.startsWith("$")) continue;
+      const next = [...path, key];
+      if (isToken(member)) {
+        flat.set(next.join("."), { token: member, type: member.$type ?? groupType });
+      } else if (isGroup(member)) {
+        walk(member, next, groupType);
+      }
+    }
+  };
+  walk(document, []);
+  const resolving = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Map();
+  const valueOf = (name) => {
+    if (resolved.has(name)) return resolved.get(name);
+    const entry = flat.get(name);
+    if (!entry) throw new Error(`Design token alias "{${name}}" does not resolve to a declared token.`);
+    if (resolving.has(name)) {
+      throw new Error(`Design token alias cycle: ${[...resolving, name].join(" -> ")}.`);
+    }
+    const raw = entry.token.$value;
+    if (typeof raw !== "string") {
+      resolved.set(name, raw);
+      return raw;
+    }
+    const alias = ALIAS.exec(raw.trim());
+    if (!alias) {
+      resolved.set(name, raw);
+      return raw;
+    }
+    resolving.add(name);
+    const target = valueOf(alias[1]);
+    resolving.delete(name);
+    resolved.set(name, target);
+    return target;
+  };
+  return [...flat.entries()].map(([name, entry]) => {
+    const value = valueOf(name);
+    return {
+      name,
+      value,
+      ...entry.type === void 0 ? {} : { type: entry.type },
+      ...entry.token.$description === void 0 ? {} : { description: entry.token.$description }
+    };
+  });
+}
+var IDENTITY_ACTOR_TYPES = [
+  "natural_person",
+  "agent",
+  "system",
+  "service_account",
+  "external_system",
+  "integration"
+];
+var ActorScopeError = class extends Error {
+  constructor(rejection, message) {
+    super(message);
+    this.rejection = rejection;
+  }
+  rejection;
+  name = "ActorScopeError";
+};
+function assertActorClaimsCoverScope(claims, scope, now = /* @__PURE__ */ new Date()) {
+  const currentTime = now.getTime();
+  if (Number.isNaN(currentTime)) {
+    throw new ActorScopeError("malformed_claims", "Actor scope was evaluated against an invalid clock.");
+  }
+  if (typeof claims.actorType !== "string" || !IDENTITY_ACTOR_TYPES.includes(claims.actorType)) {
+    throw new ActorScopeError("unknown_actor_type", `Actor type "${String(claims.actorType)}" is not a known actor kind.`);
+  }
+  if (typeof claims.subject !== "string" || claims.subject.length === 0) {
+    throw new ActorScopeError("malformed_claims", "Actor claims carry no subject.");
+  }
+  if (typeof claims.tenantId !== "string" || claims.tenantId.length === 0) {
+    throw new ActorScopeError("malformed_claims", "Actor claims carry no tenant.");
+  }
+  const issuedAt = parseRfc3339(claims.issuedAt);
+  const expiresAt = parseRfc3339(claims.expiresAt);
+  if (issuedAt === void 0 || expiresAt === void 0) {
+    throw new ActorScopeError("malformed_claims", "Actor claims carry an issuedAt or expiresAt that is not an RFC 3339 timestamp with an explicit offset.");
+  }
+  if (currentTime >= expiresAt) {
+    throw new ActorScopeError("expired", `Actor claims expired at ${claims.expiresAt}.`);
+  }
+  if (currentTime < issuedAt) {
+    throw new ActorScopeError("not_yet_valid", `Actor claims are not valid until ${claims.issuedAt}.`);
+  }
+  if (claims.tenantId !== scope.tenantId) {
+    throw new ActorScopeError(
+      "tenant_mismatch",
+      `Actor claims cover tenant "${claims.tenantId}" but the request targets "${scope.tenantId}".`
+    );
+  }
+  if (claims.spaceIds === "tenant-wide") return;
+  if (!Array.isArray(claims.spaceIds) || !claims.spaceIds.every((space) => typeof space === "string")) {
+    throw new ActorScopeError("malformed_claims", 'Actor claims spaceIds must be an array of strings or the literal "tenant-wide".');
+  }
+  if (!claims.spaceIds.includes(scope.spaceId)) {
+    throw new ActorScopeError(
+      "space_not_covered",
+      `Actor claims do not cover space "${scope.spaceId}".`
+    );
+  }
+}
+var RFC3339 = /^\d{4}-\d{2}-\d{2}[Tt]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[Zz]|[+-]\d{2}:\d{2})$/;
+function parseRfc3339(value) {
+  if (typeof value !== "string" || !RFC3339.test(value)) return void 0;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function actorContextFromClaims(claims, scope, now = /* @__PURE__ */ new Date()) {
+  assertActorClaimsCoverScope(claims, scope, now);
+  return {
+    actorId: claims.subject,
+    actorType: claims.actorType,
+    tenantId: claims.tenantId,
+    spaceId: scope.spaceId
+  };
+}
+var PORT_ID = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
+function definePort(definition) {
+  if (!PORT_ID.test(definition.id)) {
+    throw new Error(`Port id "${definition.id}" must be namespaced lowercase, for example "acme.docusign".`);
+  }
+  if (!/^\d+\.\d+\.\d+$/.test(definition.version)) {
+    throw new Error(`Port "${definition.id}" version must be a semver version.`);
+  }
+  if (!definition.description.trim()) {
+    throw new Error(`Port "${definition.id}" must describe what an adapter behind it is responsible for.`);
+  }
+  if (typeof definition.checks !== "function") {
+    throw new Error(`Port "${definition.id}" must supply a conformance suite.`);
+  }
+  return definition;
+}
+async function assertPortSuiteHasTeeth(definition, fixtures, brokenAdapters) {
+  const checks = definition.checks(fixtures);
+  if (checks.length === 0) {
+    throw new Error(`Port "${definition.id}" declares no checks, so no adapter can be certified against it.`);
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const check of checks) {
+    if (ids.has(check.id)) throw new Error(`Port "${definition.id}" declares check "${check.id}" twice.`);
+    ids.add(check.id);
+  }
+  const adapters = Array.isArray(brokenAdapters) ? brokenAdapters : [brokenAdapters];
+  if (adapters.length === 0) {
+    throw new Error(`Port "${definition.id}" needs at least one deliberately broken adapter to prove its suite bites.`);
+  }
+  const uncaught = new Set(checks.map((check) => check.id));
+  for (const adapter of adapters) {
+    for (const check of checks) {
+      if (!uncaught.has(check.id)) continue;
+      try {
+        await check.run(adapter);
+      } catch {
+        uncaught.delete(check.id);
+      }
+    }
+  }
+  if (uncaught.size > 0) {
+    throw new Error(
+      `Port "${definition.id}" has ${uncaught.size} check(s) that no supplied broken adapter trips, so they prove nothing: ${[...uncaught].join(", ")}.`
+    );
+  }
+}
+async function certifyAdapter(input) {
+  definePort(input.definition);
+  const checks = input.definition.checks(input.fixtures);
+  if (checks.length === 0) {
+    throw new Error(`Port "${input.definition.id}" declares no checks, so no adapter can be certified against it.`);
+  }
+  const passed = [];
+  for (const check of checks) {
+    try {
+      await check.run(input.adapter);
+    } catch (error) {
+      throw new Error(
+        `Adapter "${input.vendor}" failed port "${input.definition.id}" check "${check.id}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    passed.push(check.id);
+  }
+  return {
+    port: input.definition.id,
+    vendor: input.vendor,
+    ...input.version === void 0 ? {} : { version: input.version },
+    ...input.definition.standard ? { standard: input.definition.standard } : {},
+    certification: {
+      portId: input.definition.id,
+      portVersion: input.definition.version,
+      checks: passed,
+      certifiedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function isCertifiedFor(adapter, portName) {
+  const certification = adapter.certification;
+  if (!certification || typeof certification !== "object") return false;
+  if (certification.portId !== portName) return false;
+  if (certification.portId !== adapter.port) return false;
+  if (!/^\d+\.\d+\.\d+$/.test(certification.portVersion ?? "")) return false;
+  if (!Array.isArray(certification.checks) || certification.checks.length === 0) return false;
+  if (Number.isNaN(Date.parse(certification.certifiedAt ?? ""))) return false;
+  return true;
+}
+function validatePortRequirements(input) {
+  const definitions = new Map((input.definitions ?? []).map((definition) => [definition.id, definition]));
+  const findings = [];
+  for (const requirement of input.capability.requirements?.ports ?? []) {
+    const candidates = input.adapters.filter((adapter) => adapter.port === requirement.name);
+    if (candidates.length === 0) {
+      findings.push({
+        code: "unsatisfied_port",
+        port: requirement.name,
+        message: `capability "${input.capability.namespace}" requires port "${requirement.name}" and no adapter is registered for it`
+      });
+      continue;
+    }
+    let eligible = candidates;
+    if (requirement.standard) {
+      eligible = eligible.filter((adapter) => adapter.standard?.name === requirement.standard.name);
+      if (eligible.length === 0) {
+        findings.push({
+          code: "standard_not_spoken",
+          port: requirement.name,
+          message: `port "${requirement.name}" must speak "${requirement.standard.name}"; registered adapters are ${candidates.map((adapter) => `${adapter.vendor}(${adapter.standard?.name ?? "no standard"})`).join(", ")}`
+        });
+        continue;
+      }
+      if (requirement.standard.version) {
+        const atVersion = eligible.filter((adapter) => adapter.standard?.version === requirement.standard.version);
+        if (atVersion.length === 0) {
+          findings.push({
+            code: "standard_not_spoken",
+            port: requirement.name,
+            message: `port "${requirement.name}" must speak "${requirement.standard.name}" version "${requirement.standard.version}"; registered adapters speak ${eligible.map((adapter) => adapter.standard?.version ?? "an unstated version").join(", ")}`
+          });
+          continue;
+        }
+        eligible = atVersion;
+      }
+    }
+    if (requirement.version) {
+      const atVersion = eligible.filter((adapter) => adapter.version === requirement.version);
+      if (atVersion.length === 0) {
+        findings.push({
+          code: "version_mismatch",
+          port: requirement.name,
+          message: `port "${requirement.name}" requires version "${requirement.version}"; eligible adapters are ${eligible.map((adapter) => `${adapter.vendor}@${adapter.version ?? "unversioned"}`).join(", ")}`
+        });
+        continue;
+      }
+      eligible = atVersion;
+    }
+    const definition = definitions.get(requirement.name);
+    if (input.requireCertification || definition) {
+      const certified = eligible.filter((adapter) => isCertifiedFor(adapter, requirement.name));
+      if (certified.length === 0) {
+        if (input.requireCertification) {
+          findings.push({
+            code: "uncertified_adapter",
+            port: requirement.name,
+            message: `port "${requirement.name}" has eligible adapters (${eligible.map((adapter) => adapter.vendor).join(", ")}) but none carries certification evidence`
+          });
+        }
+        continue;
+      }
+      if (definition && !certified.some((adapter) => adapter.certification.portVersion === definition.version)) {
+        findings.push({
+          code: "stale_certification",
+          port: requirement.name,
+          message: `port "${requirement.name}" is at contract version ${definition.version}; adapters are certified against ${certified.map((adapter) => `${adapter.vendor}@${adapter.certification.portVersion}`).join(", ")}`
+        });
+      }
+    }
+  }
+  return { valid: findings.length === 0, findings };
+}
+function assertPortRequirementsSatisfied(input) {
+  const result = validatePortRequirements(input);
+  if (result.valid) return;
+  throw new Error([
+    `Port requirements for "${input.capability.namespace}" are not satisfied:`,
+    ...result.findings.map((finding) => `  - ${finding.message}`)
+  ].join("\n"));
+}
+var PortContractFailure = class extends Error {
+  name = "PortContractFailure";
+};
+function expect(condition, message) {
+  if (!condition) throw new PortContractFailure(message);
+}
+function flagsPortChecks() {
+  const unknownKey = "fabric.contract.definitely-not-configured";
+  return [
+    {
+      id: "flags.default-on-unknown-key",
+      title: "an unknown flag resolves to the supplied default rather than throwing",
+      async run(port) {
+        const result = await port.resolveBoolean(unknownKey, true);
+        expect(result.value === true, `an unknown flag returned ${String(result.value)} instead of the supplied default`);
+        expect(
+          result.reason === "DEFAULT" || result.reason === "ERROR",
+          `an unknown flag resolved with reason "${result.reason}"; a default or error was expected`
+        );
+      }
+    },
+    {
+      id: "flags.default-is-typed",
+      title: "each typed resolver returns its own type",
+      async run(port) {
+        expect(typeof (await port.resolveBoolean(unknownKey, false)).value === "boolean", "resolveBoolean did not return a boolean");
+        expect(typeof (await port.resolveString(unknownKey, "fallback")).value === "string", "resolveString did not return a string");
+        expect(typeof (await port.resolveNumber(unknownKey, 42)).value === "number", "resolveNumber did not return a number");
+      }
+    },
+    {
+      id: "flags.evaluation-is-pure",
+      title: "the same key and context resolve the same way twice",
+      async run(port) {
+        const context = { targetingKey: "fabric-contract-subject" };
+        const first = await port.resolveString(unknownKey, "fallback", context);
+        const second = await port.resolveString(unknownKey, "fallback", context);
+        expect(first.value === second.value, `the same evaluation returned "${first.value}" then "${second.value}"`);
+      }
+    },
+    {
+      id: "flags.tolerates-absent-context",
+      title: "evaluation without a context does not throw",
+      async run(port) {
+        await port.resolveBoolean(unknownKey, false);
+      }
+    }
+  ];
+}
+function identityPortChecks(fixtures) {
+  const checks = [
+    {
+      id: "identity.rejects-garbage",
+      title: "an unverifiable credential resolves to null rather than partial claims",
+      async run(port) {
+        const result = await port.verify("not-a-credential");
+        expect(result === null, "an unverifiable credential resolved to claims instead of null");
+      }
+    },
+    {
+      id: "identity.rejects-empty",
+      title: "an empty credential resolves to null",
+      async run(port) {
+        expect(await port.verify("") === null, "an empty credential resolved to claims");
+      }
+    },
+    {
+      id: "identity.resolves-valid",
+      title: "a valid credential resolves to the expected subject and tenant",
+      async run(port) {
+        const claims = await port.verify(fixtures.validCredential);
+        expect(claims !== null, "a valid credential failed to verify");
+        expect(claims?.subject === fixtures.expected.subject, `subject was "${claims?.subject}"`);
+        expect(claims?.tenantId === fixtures.expected.tenantId, `tenantId was "${claims?.tenantId}"`);
+      }
+    },
+    {
+      id: "identity.claims-are-complete",
+      title: "resolved claims carry every field the platform derives actor context from",
+      async run(port) {
+        const claims = await port.verify(fixtures.validCredential);
+        expect(claims !== null, "a valid credential failed to verify");
+        if (!claims) return;
+        expect(IDENTITY_ACTOR_TYPES.includes(claims.actorType), `actorType "${claims.actorType}" is not a known actor kind`);
+        expect(typeof claims.issuer === "string" && claims.issuer.length > 0, "claims carry no issuer");
+        expect(RFC3339.test(claims.issuedAt), `issuedAt "${claims.issuedAt}" is not RFC 3339 with an explicit offset`);
+        expect(RFC3339.test(claims.expiresAt), `expiresAt "${claims.expiresAt}" is not RFC 3339 with an explicit offset`);
+        expect(typeof claims.tenantId === "string" && claims.tenantId.length > 0, "claims carry no tenant");
+        expect(
+          claims.spaceIds === "tenant-wide" || Array.isArray(claims.spaceIds),
+          'spaceIds must be an explicit list or the literal "tenant-wide"'
+        );
+      }
+    },
+    {
+      id: "identity.carries-no-credential-material",
+      title: "resolved claims never echo the credential back",
+      async run(port) {
+        const claims = await port.verify(fixtures.validCredential);
+        expect(claims !== null, "a valid credential failed to verify, so this check proved nothing");
+        if (!claims) return;
+        const serialized = JSON.stringify(claims);
+        expect(
+          !serialized.includes(fixtures.validCredential),
+          "resolved claims contain the presented credential; claims must carry an opaque reference instead"
+        );
+      }
+    },
+    {
+      id: "identity.verification-is-stable",
+      title: "the same credential resolves the same subject twice",
+      async run(port) {
+        const first = await port.verify(fixtures.validCredential);
+        const second = await port.verify(fixtures.validCredential);
+        expect(first?.subject === second?.subject, "the same credential resolved to two different subjects");
+      }
+    }
+  ];
+  if (fixtures.expiredCredential !== void 0) {
+    checks.push({
+      id: "identity.rejects-expired",
+      title: "an expired credential resolves to null rather than stale claims",
+      async run(port) {
+        const expiredCredential = fixtures.expiredCredential;
+        expect(await port.verify(expiredCredential) === null, "an expired credential still resolved to claims");
+      }
+    });
+  }
+  return checks;
+}
+function contentPortChecks(fixtures) {
+  return [
+    {
+      id: "content.missing-resolves-null",
+      title: "an unauthored key resolves to null rather than an invented default",
+      async run(port) {
+        const result = await port.resolve({ ...fixtures.present, key: fixtures.absentKey });
+        expect(result === null, "an unauthored key resolved to content instead of null");
+      }
+    },
+    {
+      id: "content.revision-is-stable",
+      title: "identical content resolves the same revision twice",
+      async run(port) {
+        const first = await port.resolve(fixtures.present);
+        const second = await port.resolve(fixtures.present);
+        expect(first !== null && second !== null, "the fixture key is not authored");
+        expect(first?.revision === second?.revision, "the same content reported two revisions, so it cannot be cached");
+      }
+    },
+    {
+      id: "content.carries-no-capability-reference",
+      title: "authored content never carries a capability reference",
+      async run(port) {
+        const result = await port.resolve(fixtures.present);
+        expect(
+          !JSON.stringify(result ?? {}).includes("capability://"),
+          "content carried a capability reference; what a screen may reach is decided by a release, not by an author"
+        );
+      }
+    }
+  ];
+}
+function paymentsPortChecks(fixtures) {
+  return [
+    {
+      id: "payments.rejects-non-integer-amount",
+      title: "a fractional minor-unit amount is refused rather than rounded",
+      async run(port) {
+        let refused = false;
+        try {
+          await port.charge({ ...fixtures.request, amount: { ...fixtures.request.amount, amount: 10.5 } });
+        } catch {
+          refused = true;
+        }
+        expect(refused, "a fractional minor-unit amount was accepted; money is an integer or it drifts");
+        const control = await port.charge({
+          ...fixtures.request,
+          idempotencyKey: `${fixtures.request.idempotencyKey}:integer-probe`
+        });
+        expect(
+          control.outcome === "succeeded",
+          `the fixture charge resolved "${control.outcome}"; a suite run against an adapter that never succeeds certifies nothing`
+        );
+      }
+    },
+    {
+      id: "payments.requires-idempotency-key",
+      title: "a charge without a stable key is refused",
+      async run(port) {
+        let refused = false;
+        try {
+          await port.charge({ ...fixtures.request, idempotencyKey: "" });
+        } catch {
+          refused = true;
+        }
+        expect(refused, "a charge with no idempotency key was accepted; a retry would move money twice");
+      }
+    },
+    {
+      id: "payments.same-key-moves-money-once",
+      title: "the same idempotency key resolves to the same provider reference",
+      async run(port) {
+        const first = await port.charge(fixtures.request);
+        const second = await port.charge(fixtures.request);
+        expect(
+          first.outcome === second.outcome,
+          `the same key produced "${first.outcome}" then "${second.outcome}"`
+        );
+        expect(
+          first.outcome !== "succeeded" || first.providerReference !== void 0,
+          "a succeeded charge carried no provider reference, so a retry cannot be told from a second charge"
+        );
+        expect(
+          first.providerReference === second.providerReference,
+          "the same key produced two provider references, so a retry charged twice"
+        );
+      }
+    },
+    {
+      id: "payments.outcome-is-declared",
+      title: "an outcome is one of the three the platform can act on",
+      async run(port) {
+        const result = await port.charge(fixtures.request);
+        expect(
+          result.outcome === "succeeded" || result.outcome === "failed" || result.outcome === "ambiguous",
+          `outcome "${result.outcome}" is not one the platform can reconcile`
+        );
+      }
+    }
+  ];
+}
+function searchPortChecks(fixtures) {
+  return [
+    {
+      id: "search.fixture-returns-hits",
+      title: "the fixture query matches something, so the checks below are not vacuous",
+      async run(port) {
+        const result = await port.query(fixtures.query);
+        expect(
+          result.hits.length > 0,
+          "the fixture query returned nothing, so every check below passes without exercising the adapter"
+        );
+      }
+    },
+    {
+      id: "search.respects-limit",
+      title: "a result set never exceeds the requested limit",
+      async run(port) {
+        const result = await port.query({ ...fixtures.query, limit: 1 });
+        expect(result.hits.length <= 1, `returned ${result.hits.length} hits for a limit of 1`);
+      }
+    },
+    {
+      id: "search.returns-identifiers-not-records",
+      title: "a hit carries an identifier a governed read can resolve, not the record",
+      async run(port) {
+        const result = await port.query(fixtures.query);
+        for (const hit of result.hits) {
+          expect(typeof hit.id === "string" && hit.id.length > 0, "a hit carried no identifier");
+          expect(
+            Object.keys(hit).every((key) => key === "id" || key === "score"),
+            "a hit carried record fields; search results are pointers, and reading one still goes through ProjectionHost"
+          );
+        }
+      }
+    }
+  ];
+}
+function customerRecordPortChecks(fixtures) {
+  return [
+    {
+      // This proves redelivery does not *fail*. Whether it duplicates is not
+      // observable through this port, which has no read side by design, so
+      // the suite says what it can and does not imply more.
+      id: "crm.redelivery-does-not-fail",
+      title: "recording the same event twice is not an error",
+      async run(port) {
+        await port.record(fixtures.event);
+        await port.record(fixtures.event);
+      }
+    },
+    {
+      id: "crm.rejects-unidentified-event",
+      title: "an event with no stable id is refused",
+      async run(port) {
+        let refused = false;
+        try {
+          await port.record({ ...fixtures.event, eventId: "" });
+        } catch {
+          refused = true;
+        }
+        expect(refused, "an event with no id was accepted; redelivery would duplicate the record");
+      }
+    }
+  ];
+}
+function designTokensPortChecks(theme) {
+  return [
+    {
+      id: "tokens.theme-resolves",
+      title: "a known theme resolves to at least one token",
+      async run(port) {
+        const tokens = await port.resolve(theme);
+        expect(Array.isArray(tokens) && tokens.length > 0, `theme "${theme}" resolved to no tokens`);
+      }
+    },
+    {
+      id: "tokens.no-unresolved-aliases",
+      title: "no resolved token still carries an alias",
+      async run(port) {
+        for (const token of await port.resolve(theme)) {
+          expect(
+            typeof token.value !== "string" || !ALIAS.test(token.value.trim()),
+            `token "${token.name}" resolved to the unfollowed alias ${String(token.value)}`
+          );
+        }
+      }
+    },
+    {
+      id: "tokens.names-are-unique",
+      title: "token names are unique within a theme",
+      async run(port) {
+        const names = (await port.resolve(theme)).map((token) => token.name);
+        expect(new Set(names).size === names.length, "the theme resolved duplicate token names");
+      }
+    }
+  ];
+}
+async function runPortContract(port, checks) {
+  const failures = [];
+  for (const check of checks) {
+    try {
+      await check.run(port);
+    } catch (error) {
+      failures.push({ id: check.id, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { passed: failures.length === 0, failures };
+}
+
+export {
+  resolveDesignTokens,
+  IDENTITY_ACTOR_TYPES,
+  ActorScopeError,
+  assertActorClaimsCoverScope,
+  actorContextFromClaims,
+  definePort,
+  assertPortSuiteHasTeeth,
+  certifyAdapter,
+  validatePortRequirements,
+  assertPortRequirementsSatisfied,
+  flagsPortChecks,
+  identityPortChecks,
+  contentPortChecks,
+  paymentsPortChecks,
+  searchPortChecks,
+  customerRecordPortChecks,
+  designTokensPortChecks,
+  runPortContract
+};
+//# sourceMappingURL=chunk-FH6OL7JX.js.map