@fabricorg/assembly 0.4.7 → 0.4.9

package/dist/index.d.ts

@@ -1,45 +1,45 @@
-import { RegisteredAdapter, AdapterCertification } from '@fabricorg/ports';
-import { AdoptionBinding, BindingFinding, ComponentPackManifest } from '@fabricorg/adoption-bindings';
-import { UsageContractDocument, UsageContract } from '@fabricorg/gen-capability';
-
+import { AdapterCertification, RegisteredAdapter } from "@fabricorg/ports";
+import { AdoptionBinding, BindingFinding, ComponentPackManifest } from "@fabricorg/adoption-bindings";
+import { UsageContract, UsageContractDocument } from "@fabricorg/gen-capability";
+//#region index.d.ts
 /**
  * Version of the assembly manifest document. A vertical negotiates on this, not
  * on this package's version, and it moves only when the serialized shape changes.
  */
-declare const ASSEMBLY_MANIFEST_FORMAT_VERSION: 2;
+export declare const ASSEMBLY_MANIFEST_FORMAT_VERSION: 2;
 /**
  * Version of the resolved lockfile document. Bump when the serialized shape
  * changes in a way a consumer must detect.
  */
-declare const ASSEMBLY_LOCKFILE_FORMAT_VERSION: 2;
+export declare const ASSEMBLY_LOCKFILE_FORMAT_VERSION: 2;
 interface SemverVersion {
-    major: number;
-    minor: number;
-    patch: number;
-    prerelease: string[];
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: string[];
 }
 type Comparator = (version: SemverVersion) => boolean;
 interface ParsedComparator {
-    operator: string;
-    comparator: Comparator;
-    raw: string;
-    rangeVersion: SemverVersion | undefined;
+  operator: string;
+  comparator: Comparator;
+  raw: string;
+  rangeVersion: SemverVersion | undefined;
 }
 /**
  * A parsed semver range — a conjunction of comparators. Every comparator must
  * be satisfied. This is the subset of npm range syntax that a deterministic
  * resolver needs: `^`, `~`, `>=`, `>`, `<=`, `<`, `=`, exact, and `*`.
  */
-interface SemverRange {
-    comparators: ParsedComparator[];
-    raw: string;
+export interface SemverRange {
+  comparators: ParsedComparator[];
+  raw: string;
 }
 /**
  * Parse a semver range string into a {@link SemverRange}. Returns `undefined`
  * for an unparseable range rather than throwing, so callers can distinguish
  * "bad range" from "no satisfying version".
  */
-declare function parseSemverRange(raw: string): SemverRange | undefined;
+export declare function parseSemverRange(raw: string): SemverRange | undefined;
 /**
  * Test whether a version string satisfies a parsed range.
  *
@@ -48,34 +48,34 @@ declare function parseSemverRange(raw: string): SemverRange | undefined;
  * follows npm semantics: `^1.0.0` does not match `1.1.0-alpha`, but
  * `^1.0.0-alpha` matches `1.0.0-alpha.2`.
  */
-declare function satisfiesRange(version: string, range: SemverRange): boolean;
+export declare function satisfiesRange(version: string, range: SemverRange): boolean;
 /**
  * Resolve a range against a list of available versions, returning the highest
  * satisfying version. Returns `undefined` when no available version satisfies
  * the range. Deterministic: the same inputs always produce the same result.
  */
-declare function resolveVersionRange(range: SemverRange, available: readonly string[]): string | undefined;
+export declare function resolveVersionRange(range: SemverRange, available: readonly string[]): string | undefined;
 /** A capability the vertical assembles, with a version range to resolve. */
-interface AssemblyCapabilityReference {
-    namespace: string;
-    /** Semver range, e.g. `^1.0.0`, `>=1.0.0 <2.0.0`, `*`. */
-    range: string;
+export interface AssemblyCapabilityReference {
+  namespace: string;
+  /** Semver range, e.g. `^1.0.0`, `>=1.0.0 <2.0.0`, `*`. */
+  range: string;
 }
 /** A component pack the vertical assembles, with a version range to resolve. */
-interface AssemblyComponentPackReference {
-    pack: string;
-    namespace: string;
-    range: string;
+export interface AssemblyComponentPackReference {
+  pack: string;
+  namespace: string;
+  range: string;
 }
 /** An adoption binding the vertical declares against a capability. */
-interface AssemblyBindingEntry {
-    capability: string;
-    binding: AdoptionBinding;
+export interface AssemblyBindingEntry {
+  capability: string;
+  binding: AdoptionBinding;
 }
 /** A usage contract the vertical depends on, supplied inline for validation. */
-interface AssemblyContractEntry {
-    namespace: string;
-    document: UsageContractDocument;
+export interface AssemblyContractEntry {
+  namespace: string;
+  document: UsageContractDocument;
 }
 /**
  * An adapter the vertical deploys behind a port, with the certification the
@@ -83,13 +83,13 @@ interface AssemblyContractEntry {
  * vertical passes that straight in. Without a certification the adapter is a
  * claim, and resolution refuses it for any port a contract requires.
  */
-interface AssemblyAdapterEntry extends RegisteredAdapter {
-    certification?: AdapterCertification;
+export interface AssemblyAdapterEntry extends RegisteredAdapter {
+  certification?: AdapterCertification;
 }
 /** A port contract in force, so a certification against an older contract is stale. */
-interface AssemblyPortDefinition {
-    id: string;
-    version: string;
+export interface AssemblyPortDefinition {
+  id: string;
+  version: string;
 }
 /**
  * What a vertical assembles: the capabilities it depends on, the component
@@ -97,29 +97,29 @@ interface AssemblyPortDefinition {
  * it validates against. This is the build-time input; the lockfile is the
  * resolved output.
  */
-interface AssemblyManifest {
-    formatVersion: typeof ASSEMBLY_MANIFEST_FORMAT_VERSION;
-    /** Lowercase identifier for the vertical application. */
-    application: string;
-    capabilities: AssemblyCapabilityReference[];
-    componentPacks: AssemblyComponentPackReference[];
-    bindings: AssemblyBindingEntry[];
-    contracts: AssemblyContractEntry[];
-    /**
-     * Adapters deployed behind the ports the contracts require. Declaring the
-     * field, even empty, engages the adapter plane: every port a contract
-     * requires must then be satisfied by a certified adapter listed here, or
-     * the assembly does not resolve. An assembly that does not declare it
-     * resolves as before, with port satisfaction as a separate deployment gate.
-     */
-    adapters?: AssemblyAdapterEntry[];
+export interface AssemblyManifest {
+  formatVersion: typeof ASSEMBLY_MANIFEST_FORMAT_VERSION;
+  /** Lowercase identifier for the vertical application. */
+  application: string;
+  capabilities: AssemblyCapabilityReference[];
+  componentPacks: AssemblyComponentPackReference[];
+  bindings: AssemblyBindingEntry[];
+  contracts: AssemblyContractEntry[];
+  /**
+   * Adapters deployed behind the ports the contracts require. Declaring the
+   * field, even empty, engages the adapter plane: every port a contract
+   * requires must then be satisfied by a certified adapter listed here, or
+   * the assembly does not resolve. An assembly that does not declare it
+   * resolves as before, with port satisfaction as a separate deployment gate.
+   */
+  adapters?: AssemblyAdapterEntry[];
 }
 /** A published capability version available for resolution. */
-interface AvailableCapability {
-    namespace: string;
-    version: string;
-    /** SHA-256 manifest digest from the compiler IR. */
-    manifestDigest: string;
+export interface AvailableCapability {
+  namespace: string;
+  version: string;
+  /** SHA-256 manifest digest from the compiler IR. */
+  manifestDigest: string;
 }
 /**
  * Where a federated pack is loaded from, and what proves it is the pack that
@@ -127,99 +127,99 @@ interface AvailableCapability {
  * remote entry is what a shell actually executes, so it needs its own integrity
  * value or the review covers something other than what runs.
  */
-interface ComponentPackRemote {
-    /** Remote entry URL the shell loads. */
-    entry: string;
-    /** Subresource-integrity value for that entry, e.g. `sha384-…`. */
-    integrity: string;
-    /** Exposed module path keyed by the component name it provides. */
-    exposes: Record<string, string>;
+export interface ComponentPackRemote {
+  /** Remote entry URL the shell loads. */
+  entry: string;
+  /** Subresource-integrity value for that entry, e.g. `sha384-…`. */
+  integrity: string;
+  /** Exposed module path keyed by the component name it provides. */
+  exposes: Record<string, string>;
 }
 /** A published component pack version available for resolution. */
-interface AvailableComponentPack {
-    pack: string;
-    namespace: string;
-    version: string;
-    /** SHA-256 digest of the published component-pack artifact. */
-    artifactDigest: string;
-    /** Present when this pack is delivered as a federated remote. */
-    remote?: ComponentPackRemote;
+export interface AvailableComponentPack {
+  pack: string;
+  namespace: string;
+  version: string;
+  /** SHA-256 digest of the published component-pack artifact. */
+  artifactDigest: string;
+  /** Present when this pack is delivered as a federated remote. */
+  remote?: ComponentPackRemote;
 }
 /** A resolved capability in the lockfile. */
-interface ResolvedCapability {
-    namespace: string;
-    version: string;
-    range: string;
-    manifestDigest: string;
-    /** Digest of the exact generated usage-contract document validated for this capability. */
-    usageContractDigest?: string;
+export interface ResolvedCapability {
+  namespace: string;
+  version: string;
+  range: string;
+  manifestDigest: string;
+  /** Digest of the exact generated usage-contract document validated for this capability. */
+  usageContractDigest?: string;
 }
 /** A resolved component pack in the lockfile. */
-interface ResolvedComponentPack {
-    pack: string;
-    namespace: string;
-    version: string;
-    range: string;
-    artifactDigest: string;
-    /** Locked delivery binding, when the pack is a federated remote. */
-    remote?: ComponentPackRemote;
+export interface ResolvedComponentPack {
+  pack: string;
+  namespace: string;
+  version: string;
+  range: string;
+  artifactDigest: string;
+  /** Locked delivery binding, when the pack is a federated remote. */
+  remote?: ComponentPackRemote;
 }
 /** A validated adoption binding in the lockfile. */
-interface ResolvedBinding {
-    capability: string;
-    bindingDigest: string;
-    valid: boolean;
-    findings: BindingFinding[];
+export interface ResolvedBinding {
+  capability: string;
+  bindingDigest: string;
+  valid: boolean;
+  findings: BindingFinding[];
 }
 /**
  * A certified adapter locked into the assembly. The certification itself is
  * summarised by digest so the lockfile stays small and the evidence stays
  * verifiable: the same certification produces the same digest.
  */
-interface ResolvedAdapter {
-    port: string;
-    vendor: string;
+export interface ResolvedAdapter {
+  port: string;
+  vendor: string;
+  version?: string;
+  standard?: {
+    name: string;
     version?: string;
-    standard?: {
-        name: string;
-        version?: string;
-    };
-    /** Whether a certification was declared. An uncertified adapter is recorded so the lockfile says what is deployed, and refused wherever a contract requires its port. */
-    certified: boolean;
-    /** Port contract version the adapter was certified against. */
-    portVersion?: string;
-    certifiedAt?: string;
-    /** SHA-256 of the whole canonical certification record. */
-    certificationDigest?: string;
+  };
+  /** Whether a certification was declared. An uncertified adapter is recorded so the lockfile says what is deployed, and refused wherever a contract requires its port. */
+  certified: boolean;
+  /** Port contract version the adapter was certified against. */
+  portVersion?: string;
+  certifiedAt?: string;
+  /** SHA-256 of the whole canonical certification record. */
+  certificationDigest?: string;
 }
 /**
  * The deterministic, resolved output of assembling a vertical. Every version
  * is locked, every binding is validated, and the whole document carries a
  * canonical digest so two builds with the same inputs produce the same lockfile.
  */
-interface AssemblyLockfile {
-    formatVersion: typeof ASSEMBLY_LOCKFILE_FORMAT_VERSION;
-    application: string;
-    /** SHA-256 of this lockfile's canonical resolved body, excluding this field. */
-    assemblyDigest: string;
-    capabilities: ResolvedCapability[];
-    componentPacks: ResolvedComponentPack[];
-    bindings: ResolvedBinding[];
-    /** Present when the manifest declared adapters; covered by the digest. */
-    adapters?: ResolvedAdapter[];
+export interface AssemblyLockfile {
+  formatVersion: typeof ASSEMBLY_LOCKFILE_FORMAT_VERSION;
+  application: string;
+  /** SHA-256 of this lockfile's canonical resolved body, excluding this field. */
+  assemblyDigest: string;
+  capabilities: ResolvedCapability[];
+  componentPacks: ResolvedComponentPack[];
+  bindings: ResolvedBinding[];
+  /** Present when the manifest declared adapters; covered by the digest. */
+  adapters?: ResolvedAdapter[];
 }
-type AssemblyFindingCode = "duplicate_capability" | "duplicate_component_pack" | "unresolved_capability" | "unresolved_component_pack" | "invalid_range" | "unknown_contract_for_binding" | "contract_namespace_mismatch" | "contract_manifest_digest_mismatch" | "binding_validation_failed" | "invalid_contract" | "invalid_component_pack" | "missing_component_pack_manifest" | "component_pack_artifact_digest_mismatch" | "duplicate_contract" | "duplicate_adapter" | "unsatisfied_port" | "standard_not_spoken" | "version_mismatch" | "uncertified_adapter" | "stale_certification";
-interface AssemblyFinding {
-    code: AssemblyFindingCode;
-    path: string;
-    message: string;
+export type AssemblyFindingCode = "duplicate_capability" | "duplicate_component_pack" | "unresolved_capability" | "unresolved_component_pack" | "invalid_range" | "unknown_contract_for_binding" | "contract_namespace_mismatch" | "contract_manifest_digest_mismatch" | "binding_validation_failed" | "invalid_contract" | "invalid_component_pack" | "missing_component_pack_manifest" | "component_pack_artifact_digest_mismatch" | "duplicate_contract" | "duplicate_adapter" | "unsatisfied_port" | "standard_not_spoken" | "version_mismatch" | "uncertified_adapter" | "stale_certification";
+export interface AssemblyFinding {
+  code: AssemblyFindingCode;
+  path: string;
+  message: string;
 }
-interface AssemblyResult {
-    lockfile: AssemblyLockfile | undefined;
-    findings: AssemblyFinding[];
+export interface AssemblyResult {
+  lockfile: AssemblyLockfile | undefined;
+  findings: AssemblyFinding[];
 }
 /** Compute the digest stored for an exact generated usage-contract document. */
-declare function computeUsageContractDocumentDigest(document: UsageContractDocument): string;
+export declare function computeUsageContractDocumentDigest(document: UsageContractDocument): string;
 /**
  * The canonical digest of a lockfile's resolved content.
  *
@@ -229,28 +229,28 @@ declare function computeUsageContractDocumentDigest(document: UsageContractDocum
  * forged lockfile still fails downstream, because a release binds the assembly
  * digest it was validated against.
  */
-declare function computeAssemblyLockfileDigest(lockfile: Omit<AssemblyLockfile, "assemblyDigest">): string;
+export declare function computeAssemblyLockfileDigest(lockfile: Omit<AssemblyLockfile, "assemblyDigest">): string;
 /** The digest a certification record locks under: the whole record, keys sorted, checks sorted. */
-declare function computeAdapterCertificationDigest(certification: AdapterCertification): string;
+export declare function computeAdapterCertificationDigest(certification: AdapterCertification): string;
 /**
  * Structural validation of an assembly manifest. Checks the document's own
  * shape; does not resolve ranges or validate contracts/bindings.
  */
-declare function assertAssemblyManifest(value: unknown, path?: string): asserts value is AssemblyManifest;
+export declare function assertAssemblyManifest(value: unknown, path?: string): asserts value is AssemblyManifest;
 /**
  * Structural validation of a component pack manifest.
  */
-declare function assertComponentPackManifest(value: unknown, path?: string): asserts value is ComponentPackManifest;
+export declare function assertComponentPackManifest(value: unknown, path?: string): asserts value is ComponentPackManifest;
 /**
  * Validate a resolved lockfile and verify that its digest still identifies its
  * exact application, capability, pack, contract, and binding content.
  */
-declare function assertAssemblyLockfile(value: unknown, path?: string): asserts value is AssemblyLockfile;
+export declare function assertAssemblyLockfile(value: unknown, path?: string): asserts value is AssemblyLockfile;
 /**
  * Verify that the capability artifacts loaded by a runtime are exactly those
  * approved by an integrity-checked assembly lockfile.
  */
-declare function assertAssemblyRuntimeCompatible(lockfile: AssemblyLockfile, loadedCapabilities: readonly AvailableCapability[], 
+export declare function assertAssemblyRuntimeCompatible(lockfile: AssemblyLockfile, loadedCapabilities: readonly AvailableCapability[],
 /**
  * The adapters this runtime registered, when the lockfile carries an
  * adapter plane. Every locked certified adapter must be registered under
@@ -259,24 +259,24 @@ declare function assertAssemblyRuntimeCompatible(lockfile: AssemblyLockfile, loa
  * port is what was approved.
  */
 registeredAdapters?: readonly AssemblyAdapterEntry[]): void;
-interface ResolveAssemblyInput {
-    manifest: AssemblyManifest;
-    /** Published capability versions available for resolution. */
-    capabilities: AvailableCapability[];
-    /** Published component pack versions available for resolution. */
-    componentPacks: AvailableComponentPack[];
-    /** Component pack manifests for binding validation. */
-    packManifests?: ComponentPackManifest[];
-    /** Core component vocabulary every renderer implements. */
-    coreComponents?: readonly string[];
-    /** Contracts available for cross-capability fragment resolution. */
-    availableContracts?: UsageContract[];
-    /**
-     * Port contracts in force. With them, a certification issued against an
-     * older port version is `stale_certification`; without them, only its
-     * presence is checked.
-     */
-    portDefinitions?: readonly AssemblyPortDefinition[];
+export interface ResolveAssemblyInput {
+  manifest: AssemblyManifest;
+  /** Published capability versions available for resolution. */
+  capabilities: AvailableCapability[];
+  /** Published component pack versions available for resolution. */
+  componentPacks: AvailableComponentPack[];
+  /** Component pack manifests for binding validation. */
+  packManifests?: ComponentPackManifest[];
+  /** Core component vocabulary every renderer implements. */
+  coreComponents?: readonly string[];
+  /** Contracts available for cross-capability fragment resolution. */
+  availableContracts?: UsageContract[];
+  /**
+   * Port contracts in force. With them, a certification issued against an
+   * older port version is `stale_certification`; without them, only its
+   * presence is checked.
+   */
+  portDefinitions?: readonly AssemblyPortDefinition[];
 }
 /**
  * Resolve an assembly manifest into a deterministic lockfile. This is the
@@ -289,22 +289,22 @@ interface ResolveAssemblyInput {
  * everything it has to change. Use {@link assertAssemblyResolved} to throw
  * on the first invalid result.
  */
-declare function resolveAssembly(input: ResolveAssemblyInput): AssemblyResult;
+export declare function resolveAssembly(input: ResolveAssemblyInput): AssemblyResult;
 /**
  * Throw with every finding listed, for use as a build step. Returns the
  * lockfile when valid.
  */
-declare function assertAssemblyResolved(input: ResolveAssemblyInput): AssemblyLockfile;
+export declare function assertAssemblyResolved(input: ResolveAssemblyInput): AssemblyLockfile;
 /**
  * Validate an assembly manifest's bindings as a standalone build gate,
  * without resolving versions. Useful when versions are already locked and
  * only the binding contracts need checking.
  */
-declare function validateAssemblyBindings(input: {
-    manifest: AssemblyManifest;
-    packManifests?: ComponentPackManifest[];
-    coreComponents?: readonly string[];
-    availableContracts?: UsageContract[];
+export declare function validateAssemblyBindings(input: {
+  manifest: AssemblyManifest;
+  packManifests?: ComponentPackManifest[];
+  coreComponents?: readonly string[];
+  availableContracts?: UsageContract[];
 }): AssemblyResult;
-
-export { ASSEMBLY_LOCKFILE_FORMAT_VERSION, ASSEMBLY_MANIFEST_FORMAT_VERSION, type AssemblyAdapterEntry, type AssemblyBindingEntry, type AssemblyCapabilityReference, type AssemblyComponentPackReference, type AssemblyContractEntry, type AssemblyFinding, type AssemblyFindingCode, type AssemblyLockfile, type AssemblyManifest, type AssemblyPortDefinition, type AssemblyResult, type AvailableCapability, type AvailableComponentPack, type ComponentPackRemote, type ResolveAssemblyInput, type ResolvedAdapter, type ResolvedBinding, type ResolvedCapability, type ResolvedComponentPack, type SemverRange, assertAssemblyLockfile, assertAssemblyManifest, assertAssemblyResolved, assertAssemblyRuntimeCompatible, assertComponentPackManifest, computeAdapterCertificationDigest, computeAssemblyLockfileDigest, computeUsageContractDocumentDigest, parseSemverRange, resolveAssembly, resolveVersionRange, satisfiesRange, validateAssemblyBindings };
+//#endregion
+export {};