@kindgi/capabilities 0.0.0-bootstrap.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Kindgi Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,113 @@
-# @kindgi/capabilities
+# `@kindgi/capabilities`
 
-A placeholder. Releases come from https://github.com/kindgi/kindgi-sdk.
+Capability declarations, a tenant-scoped model-provider registry, and a deterministic router for Kindgi. An agent declares what it needs from a model (features, context window, cost, region, latency, provider or model allow and deny lists) and what it prefers; the router picks a `(provider, model)` pair from the tenant's registered providers that meets every hard requirement and the tenant's policy, ranked by the preferences. The package also defines `ModelProvider`, the provider-neutral contract that model adapters implement.
+
+## Purpose
+
+Keep agent definitions independent of any one model vendor. Agents state requirements instead of naming a model; the binding to a concrete model happens at run time, and when nothing qualifies the router returns a structured explanation of which candidate failed which requirement. Providers are registered per tenant, so routing for one tenant never sees another tenant's providers.
+
+## Exports
+
+- **Declaring requirements**
+  - **`Capability`** — `{ kind?, needs, prefer?, budget? }`. `kind` defaults to `DEFAULT_CAPABILITY_KIND` (`'llm-inference'`); `BUILT_IN_CAPABILITY_KINDS` / `BuiltInCapabilityKind` list the well-known kinds, and `CapabilityKind` is an open string.
+  - **`Requirement`** — hard constraints: `{ feature }`, `{ contextWindow: { op, value } }`, `{ costPerCall: { op, usd } }` (compared against the model's prompt price per 1K tokens), `{ region }`, `{ p95LatencyMs: { op, value } }`, `{ providers: { allow?, deny? } }`, `{ models: { allow?, deny? } }`. Operators are `ComparisonOp` (`>=`, `>`, `=`, `<=`, `<`) and `UpperBoundOp` (`<=`, `<`) for latency.
+  - **`Preference`** — `{ feature, weight }`; `feature` is a `Feature` or a provider attribute such as `'lower-cost'`. Weights add up per candidate and may be negative.
+  - **`FEATURES`** / **`Feature`** — the closed feature set: `structured-output`, `vision`, `audio-input`, `audio-output`, `tool-use`, `parallel-tool-use`, `thinking`, `long-context`, `code-execution`, `web-search`, `file-search`, `streaming`, `batch`.
+  - **`Budget`** — `maxCostUsd`, `maxTokens`, `maxDurationMs`.
+  - **`defineCapability(spec)`** — validates a declaration against the bundled `capability.schema.json` (the same file as in [`@kindgi/specs`](../specs/); its `$id` is exported as `CAPABILITY_SCHEMA_URI`) and returns `Result<Capability, InvalidCapabilityError>`. The schema accepts `needs`, `prefer` and `budget` with every requirement except `models`, so a declaration that sets `kind` or uses a `models` requirement is rejected here even though the type and the router accept it.
+- **Providers**
+  - **`ModelProvider`** — `metadata` plus `invoke(input: ModelCallInput): Promise<ModelCallResult>`.
+  - **`ProviderMetadata`** — `id`, `region` (`'unspecified'` if not region-scoped), `models`, and optional `attributes`, `description`, `capabilityKind`. One provider is one connection that can expose several models.
+  - **`ModelInfo`** — `name`, `contextWindow`, `features`, `cost` (`promptUsdPer1kTokens`, `completionUsdPer1kTokens`), and optional `p95LatencyMs`, `maxOutputTokens`, `description`.
+- **Model call shape** — **`ModelCallInput`** (`model`, `messages`, optional `tools`, `structuredOutput`, `temperature`, `maxOutputTokens`, `abortSignal`), **`ModelMessage`** (roles `system`, `user`, `assistant`, `tool`), **`ModelToolCall`**, **`ModelToolDefinition`**, **`StructuredOutputRequest`**, **`ModelCallResult`** (`message`, `finishReason`, `usage`, `costUsd`, `durationMs`, `provider`), **`UsageCounters`**. Adapters translate these to and from their vendor SDKs.
+- **Registry**
+  - **`createProviderRegistry(seed?)`** — in-memory registry. Returns `{ registry, register }`: `register(tenantId, provider)` validates the metadata and returns a `Result` (`invalid-provider`, `duplicate-provider`); `registry` is the `ProviderRegistry` view, whose own `register` throws on the same errors.
+  - **`ProviderRegistry`** — `register`, `get`, `list`, `has`, all keyed by `tenantId`, plus optional `hydrate(tenantId)` and `invalidate(tenantId)` for implementations backed by persistent storage.
+- **Routing**
+  - **`route(input: RouteInput)`** — returns `Result<RoutingDecision, CapabilityError>`. It expands each provider into one candidate per model, filters by `kind`, `needs` and the tenant policy, ranks by summed preference weight, moves candidates matching `preferredProvider` / `preferredModel` to the front, and breaks ties on `(providerId, modelName)`. The same inputs always produce the same decision.
+  - **`RouteInput`** — `capability`, `providers` (already scoped to one tenant, e.g. `registry.list(tenantId)`), and optional `tenantPolicy`, `preferredProvider`, `preferredModel`.
+  - **`RoutingDecision`** — the chosen `provider` and `model`, a human-readable `reason`, and `alternates` (`ProviderModelPick[]`) in rank order.
+  - **`matchTuples(input)`** — the filtering step on its own: the passing candidates, unranked, or `capability-unsatisfiable` when none pass.
+  - **`TenantPolicy`** — `tenantId`, provider and model `allow` / `deny` lists, `regionAllow`, `maxCostPerCallUsd`, `maxTokensPerCall`. An allow list (or `regionAllow`) that is present restricts even when empty: `[]` allows nothing.
+- **Adapter factories** — **`createAdapterFactoryRegistry(seed?)`** returns an **`AdapterFactoryRegistry`** (`register`, `get`, `has`, `list`): a deployment-wide map from adapter id to the code that builds providers. An **`AdapterFactoryEntry`** holds `adapterId`, `capabilityKind`, a `factory` (**`AdapterFactory`**: `(input: AdapterFactoryInput) => ModelProvider`, where `AdapterFactoryInput` is `metadata` plus an optional `resolveApiKey`), and an optional `prepare(params)` that streams **`PrepareEvent`**s (`progress`, `ready`, `error`) for downloads or warm-up. Registering the same id twice throws.
+- **Errors** — **`CapabilityError`**, a union of `InvalidCapabilityError`, `InvalidProviderError`, `DuplicateProviderError`, `CapabilityUnsatisfiableError` and `BudgetExceededError`. `CapabilityUnsatisfiableError.reasons` lists, for each requirement that rejected at least one candidate, the candidates that satisfied it and a structured **`RejectionReason`** for each that did not (`missing-feature`, `context-window-mismatch`, `region-mismatch`, `tenant-denied`, `capability-kind-mismatch`, …).
+
+## Example
+
+```ts
+import { createProviderRegistry, defineCapability, route } from '@kindgi/capabilities';
+import type { ModelProvider } from '@kindgi/capabilities';
+import type { TenantId } from '@kindgi/types';
+
+// One connection to a model vendor, exposing two models.
+const acmeLlm: ModelProvider = {
+  metadata: {
+    id: 'acme-llm',
+    region: 'eu-west-1',
+    attributes: ['lower-cost'],
+    models: [
+      {
+        name: 'acme-large',
+        contextWindow: 200_000,
+        features: ['tool-use', 'structured-output', 'streaming'],
+        cost: { promptUsdPer1kTokens: 0.003, completionUsdPer1kTokens: 0.015 },
+        p95LatencyMs: 4_000,
+      },
+      {
+        name: 'acme-small',
+        contextWindow: 32_000,
+        features: ['tool-use'],
+        cost: { promptUsdPer1kTokens: 0.0002, completionUsdPer1kTokens: 0.0008 },
+      },
+    ],
+  },
+  invoke: (input) => callAcmeApi(input), // your vendor SDK call
+};
+
+const tenantId = process.env.TENANT_ID as TenantId;
+const { registry, register } = createProviderRegistry();
+const registered = register(tenantId, acmeLlm);
+if (registered.kind === 'err') throw new Error(registered.error.message);
+
+const capability = defineCapability({
+  needs: [{ feature: 'tool-use' }, { contextWindow: { op: '>=', value: 100_000 } }],
+  prefer: [{ feature: 'lower-cost', weight: 1 }],
+});
+if (capability.kind === 'err') throw new Error(capability.error.message);
+
+const decision = route({
+  capability: capability.value,
+  providers: registry.list(tenantId),
+  tenantPolicy: { tenantId, regionAllow: ['eu-west-1'] },
+});
+if (decision.kind === 'err') {
+  if (decision.error.code === 'capability-unsatisfiable') {
+    for (const r of decision.error.reasons) {
+      console.error(r.requirement, r.rejectingProviders.map((p) => `${p.id}: ${p.reason.code}`));
+    }
+  }
+  process.exit(1);
+}
+
+// acme-small fails the context-window requirement, so this is acme-llm / acme-large.
+const { provider, model } = decision.value;
+const reply = await provider.invoke({
+  model: model.name,
+  messages: [{ role: 'user', content: 'Summarize clause 4.2 in one sentence.' }],
+});
+console.log(reply.message.content, reply.costUsd);
+```
+
+## Non-goals
+
+- **No vendor adapters.** Concrete `ModelProvider` implementations live in adapter packages such as those under [`packages/adapters`](../adapters/).
+- **No cost metering.** `Budget` and `BudgetExceededError` describe limits; nothing in this package tracks spend or enforces them.
+- **No retries or failover.** `route` returns ranked `alternates`; retrying with the next candidate is up to the caller.
+- **No persistence.** Both registries are in-memory. Implementations backed by storage plug in through `ProviderRegistry.hydrate` and `invalidate`.
+
+## Related
+
+- [`@kindgi/agents`](../agents/) — routes an agent's capability declaration with `route` at the start of every turn.
+- [`@kindgi/specs`](../specs/) — `capability.schema.json`, the wire schema `defineCapability` validates against.
+- [`@kindgi/dev-echo-provider`](../dev-echo-provider/) — a `ModelProvider` for local development.
+- [`@kindgi/types`](../types/) — `TenantId` and `Result`.

package/dist/adapter-factory.d.ts

@@ -0,0 +1,121 @@
+import type { ModelProvider, ProviderMetadata } from './types.js';
+/**
+ * In-process factory-function registry — the code-side counterpart of a
+ * persistent adapter registry (`AdapterRegistryBinding` in
+ * `@kindgi/api`). A store can hold adapter records but not JavaScript
+ * functions, so the runtime keeps a Map keyed by the same adapter id
+ * the stored record uses.
+ *
+ * Populated at boot by deployment code, in lockstep with the adapters
+ * it registers in storage. A storage-backed provider registry reads a
+ * tenant's stored providers, looks up each one's adapter id here, calls
+ * the factory to instantiate a `ModelProvider`, and caches the result.
+ *
+ * Failure surfaces:
+ *   - A stored provider references an adapter id with no in-process
+ *     factory (deployment forgot to register it, or a boot ordering
+ *     bug) → `get(adapterId)` returns `undefined`, and the provider
+ *     registry fails the invocation with a clear error.
+ *   - Factory throws at construction time → propagates through the
+ *     provider registry to the caller.
+ */
+export interface AdapterFactoryEntry {
+    /** Adapter identifier — MUST equal the id of the stored adapter record. */
+    readonly adapterId: string;
+    /** Capability kind this adapter fulfils (`'llm-inference'`, `'embedding'`, ...). */
+    readonly capabilityKind: string;
+    readonly factory: AdapterFactory;
+    /**
+     * Optional download / warmup step. Adapters that need
+     * expensive one-time setup (in-process model downloads, ONNX
+     * runtime warmup, cache preheating) implement this; adapters that
+     * only need config-time construction leave it undefined.
+     *
+     * Streams `PrepareEvent`s so the caller (HTTP SSE endpoint,
+     * console progress bar) can render progress. Framework doesn't
+     * cache — implementations decide whether re-invoking `prepare` on
+     * an already-prepared adapter is a no-op or a re-check.
+     *
+     * `params` shape is adapter-specific — the framework passes it
+     * through unchanged (e.g. `{model: 'smollm2-360m'}` for
+     * in-process).
+     */
+    readonly prepare?: (params?: Readonly<Record<string, unknown>>) => AsyncIterable<PrepareEvent>;
+}
+/**
+ * Event stream emitted by `AdapterFactoryEntry.prepare()`. Shape kept
+ * deliberately open (`message` + optional numeric progress fields)
+ * so adapters with different progress models (byte-count download,
+ * step-count warmup, cache hit ratio) can populate what they know.
+ * Consumers render whichever fields are present.
+ */
+export type PrepareEvent = {
+    readonly kind: 'progress';
+    readonly message?: string;
+    /** Ratio in [0, 1] when known; absent for indeterminate progress. */
+    readonly ratio?: number;
+    readonly loadedBytes?: number;
+    readonly totalBytes?: number;
+    readonly file?: string;
+} | {
+    readonly kind: 'ready';
+    readonly message?: string;
+} | {
+    readonly kind: 'error';
+    readonly message: string;
+};
+/**
+ * Input passed to an adapter factory at instantiation time. The
+ * provider registry composes the arguments from persisted state (the
+ * stored provider `metadata`) plus a pre-bound `resolveApiKey` closure
+ * that reads the tenant-scoped secret store.
+ *
+ * Adapters that don't need credentials (dev-echo, in-process
+ * models) receive no `resolveApiKey` — they ignore the field
+ * entirely.
+ */
+export interface AdapterFactoryInput {
+    readonly metadata: ProviderMetadata;
+    /**
+     * How the adapter connects — the provider's adapter-specific,
+     * non-secret settings (a cloud project, a base URL), as registered
+     * with the provider. Credentials never go here; they come from
+     * `resolveApiKey`. Each adapter documents and validates its own keys.
+     */
+    readonly config?: AdapterConfig;
+    /**
+     * Lazy API-key resolver. Adapters that need external
+     * credentials pass this into their SDK client construction (or
+     * refresh on every invoke, as
+     * `@kindgi/adapter-model-anthropic` does).
+     */
+    readonly resolveApiKey?: () => Promise<string>;
+    /**
+     * The fetch for a provider endpoint the registration chose (a base URL).
+     * The runtime passes one that refuses the hosts its deployment forbids
+     * (`KINDGI_TENANT_HOST_ACCESS`: the cloud metadata endpoints and the
+     * server's own host). Absent: the global `fetch`.
+     */
+    readonly fetch?: typeof fetch;
+}
+/** An adapter's connection settings: flat, non-secret values. */
+export type AdapterConfig = Readonly<Record<string, string | number | boolean>>;
+export type AdapterFactory = (input: AdapterFactoryInput) => ModelProvider;
+export interface AdapterFactoryRegistry {
+    register(entry: AdapterFactoryEntry): void;
+    get(adapterId: string): AdapterFactoryEntry | undefined;
+    has(adapterId: string): boolean;
+    list(): readonly AdapterFactoryEntry[];
+}
+/**
+ * Create an in-memory `AdapterFactoryRegistry`. Global
+ * (deployment-scoped) — every tenant reads from the same map because
+ * adapter code is code, not user data.
+ *
+ * Duplicate registrations under the same `adapterId` throw at
+ * `register` time; accidental clobber of a running factory would be
+ * catastrophic. Deployments call `register` once per shipped adapter
+ * at boot.
+ */
+export declare function createAdapterFactoryRegistry(seed?: readonly AdapterFactoryEntry[]): AdapterFactoryRegistry;
+//# sourceMappingURL=adapter-factory.d.ts.map

package/dist/adapter-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-factory.d.ts","sourceRoot":"","sources":["../src/adapter-factory.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAElE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,aAAa,CAAC,YAAY,CAAC,CAAC;CAChG;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GACpB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/C;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CAC/B;AAED,iEAAiE;AACjE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;AAEhF,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,mBAAmB,KAAK,aAAa,CAAC;AAE3E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC3C,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAAC;IACxD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,IAAI,IAAI,SAAS,mBAAmB,EAAE,CAAC;CACxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,GAAE,SAAS,mBAAmB,EAAO,GACxC,sBAAsB,CA0BxB"}

package/dist/adapter-factory.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright (C) 2026 Kindgi Inc.
+/**
+ * Create an in-memory `AdapterFactoryRegistry`. Global
+ * (deployment-scoped) — every tenant reads from the same map because
+ * adapter code is code, not user data.
+ *
+ * Duplicate registrations under the same `adapterId` throw at
+ * `register` time; accidental clobber of a running factory would be
+ * catastrophic. Deployments call `register` once per shipped adapter
+ * at boot.
+ */
+export function createAdapterFactoryRegistry(seed = []) {
+    const entries = new Map();
+    function register(entry) {
+        if (entries.has(entry.adapterId)) {
+            throw new Error(`AdapterFactoryRegistry: "${entry.adapterId}" is already registered. Duplicate adapter registration at boot indicates a wiring bug.`);
+        }
+        entries.set(entry.adapterId, entry);
+    }
+    for (const entry of seed)
+        register(entry);
+    return {
+        register,
+        get(adapterId) {
+            return entries.get(adapterId);
+        },
+        has(adapterId) {
+            return entries.has(adapterId);
+        },
+        list() {
+            return [...entries.values()];
+        },
+    };
+}
+//# sourceMappingURL=adapter-factory.js.map

package/dist/adapter-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-factory.js","sourceRoot":"","sources":["../src/adapter-factory.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,iCAAiC;AAmHjC;;;;;;;;;GASG;AACH,MAAM,UAAU,4BAA4B,CAC1C,OAAuC,EAAE;IAEzC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEvD,SAAS,QAAQ,CAAC,KAA0B;QAC1C,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,4BAA4B,KAAK,CAAC,SAAS,yFAAyF,CACrI,CAAC;QACJ,CAAC;QACD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,IAAI;QAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE1C,OAAO;QACL,QAAQ;QACR,GAAG,CAAC,SAAS;YACX,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;QACD,GAAG,CAAC,SAAS;YACX,OAAO,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;QACD,IAAI;YACF,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/B,CAAC;KACF,CAAC;AACJ,CAAC"}