@fabricorg/ports 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -54,6 +54,270 @@ interface DesignTokensPort {
  * and what makes a theme file readable.
  */
 declare function resolveDesignTokens(document: DtcgGroup): ResolvedToken[];
+/**
+ * Actor kinds a verified credential can resolve to. This mirrors `ActorType` in
+ * `@fabricorg/platform`, restated here so this package keeps zero runtime
+ * dependencies. `identityPortChecks` asserts the two stay identical.
+ */
+type IdentityActorType = "natural_person" | "agent" | "system" | "service_account" | "external_system" | "integration";
+declare const IDENTITY_ACTOR_TYPES: readonly IdentityActorType[];
+/**
+ * The scopes a credential covers. `"tenant-wide"` is spelled out rather than
+ * left as an absent field, so a credential that simply forgot to carry space
+ * coverage can never be read as covering everything.
+ */
+type ActorSpaceCoverage = readonly string[] | "tenant-wide";
+/**
+ * Identity resolved from a verified credential. Every governed action,
+ * projection decision, grant and audit record derives from actor context, so
+ * this is the shape a gateway must produce before the platform is called.
+ *
+ * It carries no credential material. `credentialId` is an opaque, non-secret
+ * reference retained for audit, matching the convention used by
+ * `authorizationBindingId`.
+ */
+interface ActorClaims {
+    /** Stable subject identifier; becomes `actorId` on a governed submission. */
+    subject: string;
+    actorType: IdentityActorType;
+    tenantId: string;
+    spaceIds: ActorSpaceCoverage;
+    /** Granted scopes, if the issuer expresses authority that way. */
+    scopes?: readonly string[];
+    issuer: string;
+    /** RFC 3339 timestamps. */
+    issuedAt: string;
+    expiresAt: string;
+    /** Opaque, non-secret reference to the presented credential, for audit. */
+    credentialId?: string;
+}
+/**
+ * Verifies a presented credential and resolves it to actor claims.
+ *
+ * An implementation returns `null` for any credential it cannot positively
+ * verify — expired, malformed, wrong issuer, bad signature. It never returns
+ * partially trusted claims, and it never echoes credential material back.
+ */
+interface IdentityPort {
+    verify(credential: string): Promise<ActorClaims | null>;
+}
+type ActorScopeRejection = "malformed_claims" | "expired" | "not_yet_valid" | "tenant_mismatch" | "space_not_covered" | "unknown_actor_type";
+declare class ActorScopeError extends Error {
+    readonly rejection: ActorScopeRejection;
+    readonly name = "ActorScopeError";
+    constructor(rejection: ActorScopeRejection, message: string);
+}
+/**
+ * Confirm verified claims actually cover the tenant and space being acted on.
+ *
+ * Verification proves who the caller is. It does not prove they may act here.
+ * Calling this before a governed submission is what stops a valid credential
+ * for one tenant from being replayed against another.
+ */
+declare function assertActorClaimsCoverScope(claims: ActorClaims, scope: {
+    tenantId: string;
+    spaceId: string;
+}, now?: Date): void;
+/**
+ * The actor fields a governed submission needs, derived from verified claims
+ * after {@link assertActorClaimsCoverScope} has accepted them. Taking these
+ * from claims rather than from request input is what keeps the audit trail
+ * tied to something that was actually proven.
+ */
+declare function actorContextFromClaims(claims: ActorClaims, scope: {
+    tenantId: string;
+    spaceId: string;
+}, now?: Date): {
+    actorId: string;
+    actorType: IdentityActorType;
+    tenantId: string;
+    spaceId: string;
+};
+/**
+ * A resolved piece of authored content.
+ *
+ * Content is copy and layout, never permission. A content system deciding what
+ * a screen says is expected; a content system deciding what a screen may reach
+ * is the failure this whole boundary exists to prevent, which is why nothing
+ * here carries a capability reference.
+ */
+interface ContentEntry {
+    key: string;
+    locale: string;
+    /** Opaque revision, stable for identical content. Use it for cache keys. */
+    revision: string;
+    value: JsonLike;
+}
+type JsonLike = string | number | boolean | null | JsonLike[] | {
+    [key: string]: JsonLike;
+};
+interface ContentQuery {
+    key: string;
+    locale: string;
+    /** Optional variant, for an experiment arm already enumerated in a release. */
+    variant?: string;
+}
+interface ContentPort {
+    /** Resolves to `null` when the key is not authored, rather than inventing a default. */
+    resolve(query: ContentQuery): Promise<ContentEntry | null>;
+}
+/**
+ * Money as an integer in the currency's minor unit.
+ *
+ * Never a float. A payment expressed as 10.1 is a payment that will eventually
+ * be off by a cent, and reconciling that costs more than the type ever did.
+ */
+interface MinorUnitAmount {
+    /** Integer in the minor unit: 1050 is USD 10.50. */
+    amount: number;
+    /** ISO 4217 alphabetic code. */
+    currency: string;
+}
+/**
+ * The outcome of asking a provider to move money.
+ *
+ * `ambiguous` is the one that matters and the one most interfaces omit. A
+ * timeout tells you nothing about whether the charge landed, and guessing is
+ * how a customer gets billed twice. It maps onto the platform's own
+ * `AdapterOutcomeKind`, so an ambiguous payment routes to reconciliation with
+ * durable evidence instead of being retried.
+ */
+type PaymentOutcome = "succeeded" | "failed" | "ambiguous";
+interface PaymentResult {
+    outcome: PaymentOutcome;
+    /** The provider's own identifier, for reconciliation. Required when known. */
+    providerReference?: string;
+    /** Provider-supplied reason, for evidence rather than for branching. */
+    reason?: string;
+}
+interface PaymentRequest {
+    /** Caller-stable key. The same key must never move money twice. */
+    idempotencyKey: string;
+    amount: MinorUnitAmount;
+}
+interface PaymentsPort {
+    charge(request: PaymentRequest): Promise<PaymentResult>;
+}
+/**
+ * A latency-critical read path, deliberately outside the governed pipeline.
+ *
+ * Search results are pointers, not authority. An identifier appearing in a
+ * result set says the index knows about it, never that this actor may read it,
+ * so anything the viewer then opens still goes through `ProjectionHost`.
+ */
+interface SearchHit {
+    /** Identifier a governed read can resolve. Never the record itself. */
+    id: string;
+    score: number;
+}
+interface SearchQuery {
+    text: string;
+    limit: number;
+    /** Narrowing the index can apply cheaply. Never a substitute for authorization. */
+    filters?: Record<string, string>;
+}
+interface SearchPort {
+    query(query: SearchQuery): Promise<{
+        hits: SearchHit[];
+        total: number;
+    }>;
+}
+/**
+ * An outbound record of something that already happened.
+ *
+ * A CRM is downstream of the governed pipeline, never upstream of it. It is
+ * told; it does not decide. Keeping this one-way is what stops a marketing
+ * system becoming a source of business truth.
+ */
+interface CustomerEvent {
+    /** Stable key so redelivery does not duplicate the record. */
+    eventId: string;
+    subjectId: string;
+    type: string;
+    occurredAt: string;
+    attributes?: Record<string, JsonLike>;
+}
+interface CustomerRecordPort {
+    record(event: CustomerEvent): Promise<void>;
+}
+/**
+ * A port, as a first-class thing rather than a name in a string.
+ *
+ * Fabric ships a handful of port definitions because they speak open standards
+ * and everyone needs them. It cannot ship the rest: an enterprise integrates
+ * hundreds of external systems, and a framework that requires a pull request
+ * for each one is not a framework. A vertical, a partner or a vendor defines
+ * its own port with {@link definePort} and every mechanism here applies to it
+ * unchanged — Fabric never learns what the system behind it is.
+ *
+ * The definition binds an id to the suite that certifies an adapter for it.
+ * That binding is the point: without it, "this port is satisfied" only ever
+ * meant "somebody registered something claiming to be it".
+ */
+interface PortDefinition<TPort, TFixtures = void> {
+    /**
+     * Namespaced identifier, for example `fabric.flags` or `acme.docusign`.
+     * Namespacing is required so a port defined outside this repository cannot
+     * collide with one defined inside it.
+     */
+    id: string;
+    /**
+     * Version of the port contract itself, not of any adapter.
+     *
+     * Bump it when the interface changes shape. Certification is recorded
+     * against a version, so raising it correctly invalidates every adapter
+     * certified against the old contract instead of silently carrying them
+     * forward.
+     */
+    version: string;
+    /** The open standard this port speaks, where one exists. */
+    standard?: {
+        name: string;
+        version?: string;
+    };
+    /** One-line statement of what an adapter behind this port is responsible for. */
+    description: string;
+    /** The suite every adapter must pass. */
+    checks(fixtures: TFixtures): readonly PortCheck<TPort>[];
+}
+/**
+ * Declare a port. Validates the definition itself, because a malformed port
+ * definition produces adapters that certify against nothing.
+ */
+declare function definePort<TPort, TFixtures = void>(definition: PortDefinition<TPort, TFixtures>): PortDefinition<TPort, TFixtures>;
+/**
+ * Confirm a port's suite can actually fail, and that its check ids are unique.
+ *
+ * A suite whose checks all pass against a deliberately broken adapter certifies
+ * nothing while looking rigorous, which is worse than having no suite at all.
+ * Run this against a stub that does the wrong thing when you author a port.
+ */
+declare function assertPortSuiteHasTeeth<TPort, TFixtures>(definition: PortDefinition<TPort, TFixtures>, fixtures: TFixtures, brokenAdapters: TPort | readonly TPort[]): Promise<void>;
+/** Evidence that an adapter passed a port's suite, and which contract it passed. */
+interface AdapterCertification {
+    portId: string;
+    /** Port contract version the adapter was certified against. */
+    portVersion: string;
+    checks: string[];
+    certifiedAt: string;
+}
+interface CertifiedAdapter extends RegisteredAdapter {
+    certification: AdapterCertification;
+}
+/**
+ * Run a port's suite against an adapter and record what it passed.
+ *
+ * Registration is a claim; certification is evidence. Deployment gates can then
+ * require the second rather than accepting the first.
+ */
+declare function certifyAdapter<TPort, TFixtures>(input: {
+    definition: PortDefinition<TPort, TFixtures>;
+    fixtures: TFixtures;
+    adapter: TPort;
+    vendor: string;
+    version?: string;
+    now?: Date;
+}): Promise<CertifiedAdapter>;
 interface PortRequirement {
     name: string;
     version?: string;
@@ -79,7 +343,7 @@ interface RegisteredAdapter {
         version?: string;
     };
 }
-type PortFindingCode = "unsatisfied_port" | "standard_not_spoken" | "version_mismatch";
+type PortFindingCode = "unsatisfied_port" | "standard_not_spoken" | "version_mismatch" | "uncertified_adapter" | "stale_certification";
 interface PortFinding {
     code: PortFindingCode;
     port: string;
@@ -100,10 +364,23 @@ interface PortValidationResult {
 declare function validatePortRequirements(input: {
     capability: PortRequiringCapability;
     adapters: readonly RegisteredAdapter[];
+    /**
+     * Port definitions in force. Supplying them checks that whatever
+     * certification is present was issued against the current contract version.
+     *
+     * They do not by themselves require certification to exist: pass
+     * `requireCertification` for that. Definitions alone catch a stale
+     * certification, not a missing one, and an adapter carrying none passes.
+     */
+    definitions?: readonly PortDefinition<never, never>[];
+    /** Require certification for every required port. Defaults to false. */
+    requireCertification?: boolean;
 }): PortValidationResult;
 declare function assertPortRequirementsSatisfied(input: {
     capability: PortRequiringCapability;
     adapters: readonly RegisteredAdapter[];
+    definitions?: readonly PortDefinition<never, never>[];
+    requireCertification?: boolean;
 }): void;
 interface PortCheck<TPort> {
     id: string;
@@ -116,6 +393,36 @@ interface PortCheck<TPort> {
  * plus a configuration change rather than a migration.
  */
 declare function flagsPortChecks(): PortCheck<FlagsPort>[];
+/**
+ * The suite an identity adapter must pass before it can stand behind
+ * `IdentityPort`. Every check here is a fail-closed property: the cost of
+ * getting one wrong is a credential being trusted further than it proves.
+ *
+ * `validCredential` must be a credential the adapter verifies successfully,
+ * and `expected` the claims it should resolve to.
+ */
+declare function identityPortChecks(fixtures: {
+    validCredential: string;
+    expected: Pick<ActorClaims, "subject" | "tenantId">;
+    expiredCredential?: string;
+}): PortCheck<IdentityPort>[];
+/** The suite a content adapter must pass. */
+declare function contentPortChecks(fixtures: {
+    present: ContentQuery;
+    absentKey: string;
+}): PortCheck<ContentPort>[];
+/** The suite a payments adapter must pass. */
+declare function paymentsPortChecks(fixtures: {
+    request: PaymentRequest;
+}): PortCheck<PaymentsPort>[];
+/** The suite a search adapter must pass. */
+declare function searchPortChecks(fixtures: {
+    query: SearchQuery;
+}): PortCheck<SearchPort>[];
+/** The suite a customer-record adapter must pass. */
+declare function customerRecordPortChecks(fixtures: {
+    event: CustomerEvent;
+}): PortCheck<CustomerRecordPort>[];
 declare function designTokensPortChecks(theme: string): PortCheck<DesignTokensPort>[];
 /** Runs a contract suite and returns every failure, rather than stopping at the first. */
 declare function runPortContract<TPort>(port: TPort, checks: readonly PortCheck<TPort>[]): Promise<{
@@ -126,4 +433,4 @@ declare function runPortContract<TPort>(port: TPort, checks: readonly PortCheck<
     }>;
 }>;
 
-export { type DesignTokensPort, type DtcgGroup, type DtcgToken, type EvaluationContext, type FlagValue, type FlagsPort, type PortCheck, type PortFinding, type PortFindingCode, type PortRequirement, type PortRequiringCapability, type PortValidationResult, type RegisteredAdapter, type ResolutionDetails, type ResolutionReason, type ResolvedToken, assertPortRequirementsSatisfied, designTokensPortChecks, flagsPortChecks, resolveDesignTokens, runPortContract, validatePortRequirements };
+export { type ActorClaims, ActorScopeError, type ActorScopeRejection, type ActorSpaceCoverage, type AdapterCertification, type CertifiedAdapter, type ContentEntry, type ContentPort, type ContentQuery, type CustomerEvent, type CustomerRecordPort, type DesignTokensPort, type DtcgGroup, type DtcgToken, type EvaluationContext, type FlagValue, type FlagsPort, IDENTITY_ACTOR_TYPES, type IdentityActorType, type IdentityPort, type JsonLike, type MinorUnitAmount, type PaymentOutcome, type PaymentRequest, type PaymentResult, type PaymentsPort, type PortCheck, type PortDefinition, type PortFinding, type PortFindingCode, type PortRequirement, type PortRequiringCapability, type PortValidationResult, type RegisteredAdapter, type ResolutionDetails, type ResolutionReason, type ResolvedToken, type SearchHit, type SearchPort, type SearchQuery, actorContextFromClaims, assertActorClaimsCoverScope, assertPortRequirementsSatisfied, assertPortSuiteHasTeeth, certifyAdapter, contentPortChecks, customerRecordPortChecks, definePort, designTokensPortChecks, flagsPortChecks, identityPortChecks, paymentsPortChecks, resolveDesignTokens, runPortContract, searchPortChecks, validatePortRequirements };

package/dist/index.js

@@ -1,196 +1,41 @@
-// 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 }
-    };
-  });
-}
-function validatePortRequirements(input) {
-  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;
-    }
-    if (requirement.standard) {
-      const speaking = candidates.filter((adapter) => adapter.standard?.name === requirement.standard.name);
-      if (speaking.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.version && !candidates.some((adapter) => adapter.version === requirement.version)) {
-      findings.push({
-        code: "version_mismatch",
-        port: requirement.name,
-        message: `port "${requirement.name}" requires version "${requirement.version}"; registered adapters are ${candidates.map((adapter) => `${adapter.vendor}@${adapter.version ?? "unversioned"}`).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 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 };
-}
+import {
+  ActorScopeError,
+  IDENTITY_ACTOR_TYPES,
+  actorContextFromClaims,
+  assertActorClaimsCoverScope,
+  assertPortRequirementsSatisfied,
+  assertPortSuiteHasTeeth,
+  certifyAdapter,
+  contentPortChecks,
+  customerRecordPortChecks,
+  definePort,
+  designTokensPortChecks,
+  flagsPortChecks,
+  identityPortChecks,
+  paymentsPortChecks,
+  resolveDesignTokens,
+  runPortContract,
+  searchPortChecks,
+  validatePortRequirements
+} from "./chunk-FH6OL7JX.js";
 export {
+  ActorScopeError,
+  IDENTITY_ACTOR_TYPES,
+  actorContextFromClaims,
+  assertActorClaimsCoverScope,
   assertPortRequirementsSatisfied,
+  assertPortSuiteHasTeeth,
+  certifyAdapter,
+  contentPortChecks,
+  customerRecordPortChecks,
+  definePort,
   designTokensPortChecks,
   flagsPortChecks,
+  identityPortChecks,
+  paymentsPortChecks,
   resolveDesignTokens,
   runPortContract,
+  searchPortChecks,
   validatePortRequirements
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts"],"sourcesContent":["/**\n * Port interfaces are declared here and implemented by vendor adapters elsewhere.\n * Nothing in this package imports a vendor SDK: a port is a shape, and an adapter\n * is anything that satisfies it. Where an open standard exists the port speaks it,\n * so the incumbent vendor is already just one provider behind the interface.\n */\n\n// ── Feature flags (OpenFeature-shaped) ──────────────────────────────────────\n\nexport type FlagValue = boolean | string | number | { [key: string]: unknown };\n\nexport interface EvaluationContext {\n\t/** Stable identifier for the subject of evaluation, usually a tenant or actor. */\n\ttargetingKey?: string;\n\t[attribute: string]: unknown;\n}\n\nexport type ResolutionReason = \"STATIC\" | \"DEFAULT\" | \"TARGETING_MATCH\" | \"SPLIT\" | \"CACHED\" | \"ERROR\";\n\nexport interface ResolutionDetails<T extends FlagValue> {\n\tvalue: T;\n\treason: ResolutionReason;\n\tvariant?: string;\n\terrorCode?: string;\n}\n\n/**\n * Structurally compatible with an OpenFeature provider's evaluation surface, so an\n * OpenFeature provider is a thin adapter rather than a translation layer.\n */\nexport interface FlagsPort {\n\tresolveBoolean(flagKey: string, defaultValue: boolean, context?: EvaluationContext): Promise<ResolutionDetails<boolean>>;\n\tresolveString(flagKey: string, defaultValue: string, context?: EvaluationContext): Promise<ResolutionDetails<string>>;\n\tresolveNumber(flagKey: string, defaultValue: number, context?: EvaluationContext): Promise<ResolutionDetails<number>>;\n}\n\n// ── Design tokens (W3C DTCG) ────────────────────────────────────────────────\n\nexport interface DtcgToken {\n\t$value: unknown;\n\t$type?: string;\n\t$description?: string;\n}\n\nexport interface DtcgGroup {\n\t$type?: string;\n\t$description?: string;\n\t[member: string]: DtcgToken | DtcgGroup | string | undefined;\n}\n\nexport interface ResolvedToken {\n\tname: string;\n\tvalue: unknown;\n\ttype?: string;\n\tdescription?: string;\n}\n\nexport interface DesignTokensPort {\n\t/** Resolved tokens for one theme. Aliases are already followed. */\n\tresolve(theme: string): Promise<ResolvedToken[]>;\n}\n\nconst ALIAS = /^\\{([^}]+)\\}$/;\n\nconst isToken = (value: unknown): value is DtcgToken =>\n\t!!value && typeof value === \"object\" && !Array.isArray(value) && \"$value\" in value;\n\nconst isGroup = (value: unknown): value is DtcgGroup =>\n\t!!value && typeof value === \"object\" && !Array.isArray(value) && !(\"$value\" in value);\n\n/**\n * Flattens a DTCG document and follows aliases. `$type` is inherited from the\n * nearest ancestor group that declares one, which is what the format specifies\n * and what makes a theme file readable.\n */\nexport function resolveDesignTokens(document: DtcgGroup): ResolvedToken[] {\n\tconst flat = new Map<string, { token: DtcgToken; type?: string }>();\n\n\tconst walk = (node: DtcgGroup, path: string[], inheritedType?: string): void => {\n\t\tconst groupType = typeof node.$type === \"string\" ? node.$type : inheritedType;\n\t\tfor (const [key, member] of Object.entries(node)) {\n\t\t\tif (key.startsWith(\"$\")) continue;\n\t\t\tconst next = [...path, key];\n\t\t\tif (isToken(member)) {\n\t\t\t\tflat.set(next.join(\".\"), { token: member, type: member.$type ?? groupType });\n\t\t\t} else if (isGroup(member)) {\n\t\t\t\twalk(member, next, groupType);\n\t\t\t}\n\t\t}\n\t};\n\twalk(document, []);\n\n\tconst resolving = new Set<string>();\n\tconst resolved = new Map<string, unknown>();\n\n\tconst valueOf = (name: string): unknown => {\n\t\tif (resolved.has(name)) return resolved.get(name);\n\t\tconst entry = flat.get(name);\n\t\tif (!entry) throw new Error(`Design token alias \"{${name}}\" does not resolve to a declared token.`);\n\t\tif (resolving.has(name)) {\n\t\t\tthrow new Error(`Design token alias cycle: ${[...resolving, name].join(\" -> \")}.`);\n\t\t}\n\t\tconst raw = entry.token.$value;\n\t\tif (typeof raw !== \"string\") {\n\t\t\tresolved.set(name, raw);\n\t\t\treturn raw;\n\t\t}\n\t\tconst alias = ALIAS.exec(raw.trim());\n\t\tif (!alias) {\n\t\t\tresolved.set(name, raw);\n\t\t\treturn raw;\n\t\t}\n\t\tresolving.add(name);\n\t\tconst target = valueOf(alias[1]!);\n\t\tresolving.delete(name);\n\t\tresolved.set(name, target);\n\t\treturn target;\n\t};\n\n\treturn [...flat.entries()].map(([name, entry]) => {\n\t\tconst value = valueOf(name);\n\t\treturn {\n\t\t\tname,\n\t\t\tvalue,\n\t\t\t...(entry.type === undefined ? {} : { type: entry.type }),\n\t\t\t...(entry.token.$description === undefined ? {} : { description: entry.token.$description }),\n\t\t};\n\t});\n}\n\n// ── Requirement satisfaction ────────────────────────────────────────────────\n\nexport interface PortRequirement {\n\tname: string;\n\tversion?: string;\n\tstandard?: { name: string; version?: string };\n}\n\n/** The subset of capability metadata that declares what ports it needs. */\nexport interface PortRequiringCapability {\n\tnamespace: string;\n\trequirements?: { ports?: PortRequirement[] };\n}\n\nexport interface RegisteredAdapter {\n\t/** Port this adapter implements, matching the requirement's `name`. */\n\tport: string;\n\tvendor: string;\n\tversion?: string;\n\tstandard?: { name: string; version?: string };\n}\n\nexport type PortFindingCode = \"unsatisfied_port\" | \"standard_not_spoken\" | \"version_mismatch\";\n\nexport interface PortFinding {\n\tcode: PortFindingCode;\n\tport: string;\n\tmessage: string;\n}\n\nexport interface PortValidationResult {\n\tvalid: boolean;\n\tfindings: PortFinding[];\n}\n\n/**\n * Checks that every port a capability declares is backed by a registered adapter.\n * `CapabilityPortRequirement` is otherwise a name that resolves against nothing;\n * this is what turns the declaration into a deployment-time gate.\n *\n * Version matching is exact. Range negotiation belongs to whatever installs the\n * adapters, and pretending to do semver here would be worse than not doing it.\n */\nexport function validatePortRequirements(input: {\n\tcapability: PortRequiringCapability;\n\tadapters: readonly RegisteredAdapter[];\n}): PortValidationResult {\n\tconst findings: PortFinding[] = [];\n\tfor (const requirement of input.capability.requirements?.ports ?? []) {\n\t\tconst candidates = input.adapters.filter((adapter) => adapter.port === requirement.name);\n\t\tif (candidates.length === 0) {\n\t\t\tfindings.push({\n\t\t\t\tcode: \"unsatisfied_port\",\n\t\t\t\tport: requirement.name,\n\t\t\t\tmessage: `capability \"${input.capability.namespace}\" requires port \"${requirement.name}\" and no adapter is registered for it`,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tif (requirement.standard) {\n\t\t\tconst speaking = candidates.filter((adapter) => adapter.standard?.name === requirement.standard!.name);\n\t\t\tif (speaking.length === 0) {\n\t\t\t\tfindings.push({\n\t\t\t\t\tcode: \"standard_not_spoken\",\n\t\t\t\t\tport: requirement.name,\n\t\t\t\t\tmessage: `port \"${requirement.name}\" must speak \"${requirement.standard.name}\"; registered adapters are ${candidates.map((adapter) => `${adapter.vendor}(${adapter.standard?.name ?? \"no standard\"})`).join(\", \")}`,\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tif (requirement.version && !candidates.some((adapter) => adapter.version === requirement.version)) {\n\t\t\tfindings.push({\n\t\t\t\tcode: \"version_mismatch\",\n\t\t\t\tport: requirement.name,\n\t\t\t\tmessage: `port \"${requirement.name}\" requires version \"${requirement.version}\"; registered adapters are ${candidates.map((adapter) => `${adapter.vendor}@${adapter.version ?? \"unversioned\"}`).join(\", \")}`,\n\t\t\t});\n\t\t}\n\t}\n\treturn { valid: findings.length === 0, findings };\n}\n\nexport function assertPortRequirementsSatisfied(input: {\n\tcapability: PortRequiringCapability;\n\tadapters: readonly RegisteredAdapter[];\n}): void {\n\tconst result = validatePortRequirements(input);\n\tif (result.valid) return;\n\tthrow new Error([\n\t\t`Port requirements for \"${input.capability.namespace}\" are not satisfied:`,\n\t\t...result.findings.map((finding) => `  - ${finding.message}`),\n\t].join(\"\\n\"));\n}\n\n// ── Adapter contract kit ────────────────────────────────────────────────────\n\nexport interface PortCheck<TPort> {\n\tid: string;\n\ttitle: string;\n\t/** Throws on failure, exactly as an assertion would. */\n\trun(port: TPort): Promise<void>;\n}\n\nclass PortContractFailure extends Error {\n\toverride readonly name = \"PortContractFailure\";\n}\n\nfunction expect(condition: unknown, message: string): asserts condition {\n\tif (!condition) throw new PortContractFailure(message);\n}\n\n/**\n * Every flags adapter must pass these, so swapping vendors is an adapter build\n * plus a configuration change rather than a migration.\n */\nexport function flagsPortChecks(): PortCheck<FlagsPort>[] {\n\tconst unknownKey = \"fabric.contract.definitely-not-configured\";\n\treturn [\n\t\t{\n\t\t\tid: \"flags.default-on-unknown-key\",\n\t\t\ttitle: \"an unknown flag resolves to the supplied default rather than throwing\",\n\t\t\tasync run(port) {\n\t\t\t\tconst result = await port.resolveBoolean(unknownKey, true);\n\t\t\t\texpect(result.value === true, `an unknown flag returned ${String(result.value)} instead of the supplied default`);\n\t\t\t\texpect(\n\t\t\t\t\tresult.reason === \"DEFAULT\" || result.reason === \"ERROR\",\n\t\t\t\t\t`an unknown flag resolved with reason \"${result.reason}\"; a default or error was expected`,\n\t\t\t\t);\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tid: \"flags.default-is-typed\",\n\t\t\ttitle: \"each typed resolver returns its own type\",\n\t\t\tasync run(port) {\n\t\t\t\texpect(typeof (await port.resolveBoolean(unknownKey, false)).value === \"boolean\", \"resolveBoolean did not return a boolean\");\n\t\t\t\texpect(typeof (await port.resolveString(unknownKey, \"fallback\")).value === \"string\", \"resolveString did not return a string\");\n\t\t\t\texpect(typeof (await port.resolveNumber(unknownKey, 42)).value === \"number\", \"resolveNumber did not return a number\");\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tid: \"flags.evaluation-is-pure\",\n\t\t\ttitle: \"the same key and context resolve the same way twice\",\n\t\t\tasync run(port) {\n\t\t\t\tconst context = { targetingKey: \"fabric-contract-subject\" };\n\t\t\t\tconst first = await port.resolveString(unknownKey, \"fallback\", context);\n\t\t\t\tconst second = await port.resolveString(unknownKey, \"fallback\", context);\n\t\t\t\texpect(first.value === second.value, `the same evaluation returned \"${first.value}\" then \"${second.value}\"`);\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tid: \"flags.tolerates-absent-context\",\n\t\t\ttitle: \"evaluation without a context does not throw\",\n\t\t\tasync run(port) {\n\t\t\t\tawait port.resolveBoolean(unknownKey, false);\n\t\t\t},\n\t\t},\n\t];\n}\n\nexport function designTokensPortChecks(theme: string): PortCheck<DesignTokensPort>[] {\n\treturn [\n\t\t{\n\t\t\tid: \"tokens.theme-resolves\",\n\t\t\ttitle: \"a known theme resolves to at least one token\",\n\t\t\tasync run(port) {\n\t\t\t\tconst tokens = await port.resolve(theme);\n\t\t\t\texpect(Array.isArray(tokens) && tokens.length > 0, `theme \"${theme}\" resolved to no tokens`);\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tid: \"tokens.no-unresolved-aliases\",\n\t\t\ttitle: \"no resolved token still carries an alias\",\n\t\t\tasync run(port) {\n\t\t\t\tfor (const token of await port.resolve(theme)) {\n\t\t\t\t\texpect(\n\t\t\t\t\t\ttypeof token.value !== \"string\" || !ALIAS.test(token.value.trim()),\n\t\t\t\t\t\t`token \"${token.name}\" resolved to the unfollowed alias ${String(token.value)}`,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t},\n\t\t},\n\t\t{\n\t\t\tid: \"tokens.names-are-unique\",\n\t\t\ttitle: \"token names are unique within a theme\",\n\t\t\tasync run(port) {\n\t\t\t\tconst names = (await port.resolve(theme)).map((token) => token.name);\n\t\t\t\texpect(new Set(names).size === names.length, \"the theme resolved duplicate token names\");\n\t\t\t},\n\t\t},\n\t];\n}\n\n/** Runs a contract suite and returns every failure, rather than stopping at the first. */\nexport async function runPortContract<TPort>(port: TPort, checks: readonly PortCheck<TPort>[]): Promise<{ passed: boolean; failures: Array<{ id: string; message: string }> }> {\n\tconst failures: Array<{ id: string; message: string }> = [];\n\tfor (const check of checks) {\n\t\ttry {\n\t\t\tawait check.run(port);\n\t\t} catch (error) {\n\t\t\tfailures.push({ id: check.id, message: error instanceof Error ? error.message : String(error) });\n\t\t}\n\t}\n\treturn { passed: failures.length === 0, failures };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabricorg/ports",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Vendor-neutral port interfaces, a DTCG token resolver, and the contract-test kit every adapter must pass.",
   "license": "MIT",
   "type": "module",
@@ -17,6 +17,16 @@
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       }
+    },
+    "./catalog": {
+      "import": {
+        "types": "./dist/catalog.d.ts",
+        "default": "./dist/catalog.js"
+      },
+      "require": {
+        "types": "./dist/catalog.d.cts",
+        "default": "./dist/catalog.cjs"
+      }
     }
   },
   "files": [
@@ -29,7 +39,8 @@
     "@types/node": "^22.10.0",
     "tsup": "^8.5.0",
     "typescript": "^5.7.3",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.5",
+    "@fabricorg/platform": "1.3.0"
   },
   "publishConfig": {
     "access": "public"