@prisma-next/contract 0.1.0-dev.3 → 0.1.0-dev.30

package/README.md

@@ -1,14 +1,18 @@
 # @prisma-next/contract
 
-Data contract type definitions and JSON schema for Prisma Next.
+Core contract types, framework component descriptors, and JSON schemas for Prisma Next.
 
 ## Overview
 
-This package provides TypeScript type definitions and JSON Schemas for Prisma Next data contracts. The data contract is the canonical description of an application's data model and storage layout, independent of any specific query language or database target.
+This package provides the foundational type definitions for Prisma Next, including:
+- **Data contracts**: The canonical description of an application's data model and storage layout
+- **Framework component descriptors**: Base interfaces for the modular component system (families, targets, adapters, drivers, extensions)
+- **JSON Schemas**: Validation schemas for contract files
 
 ## Responsibilities
 
-- **Core Contract Types**: Defines framework-level contract types (`ContractBase`, `Source`) that are shared across all target families
+- **Core Contract Types**: Defines framework-level contract types (`ContractBase`, `Source`, `FamilyInstance`) that are shared across all target families
+- **Framework Component Model**: Provides base descriptor interfaces (`FamilyDescriptor`, `TargetDescriptor`, `AdapterDescriptor`, `DriverDescriptor`, `ExtensionDescriptor`) and identity instance bases (`FamilyInstance`, `TargetInstance`, `AdapterInstance`, `DriverInstance`, `ExtensionInstance`) that plane-specific types extend
 - **Document Family Types**: Provides TypeScript types for document target family contracts (`DocumentContract`)
 - **JSON Schema Validation**: Provides JSON Schemas for validating contract structure in IDEs and tooling
 - **Type Guards**: Provides runtime type guards for narrowing contract types (`isDocumentContract`)
@@ -69,6 +73,68 @@ const myFamilyHook: TargetFamilyHook = {
 };
 ```
 
+### Framework Component Model
+
+Import base descriptor and instance interfaces to define or type-check framework components:
+
+```typescript
+import type {
+  // Descriptors
+  ComponentDescriptor,
+  FamilyDescriptor,
+  TargetDescriptor,
+  AdapterDescriptor,
+  DriverDescriptor,
+  ExtensionDescriptor,
+  // Instances
+  FamilyInstance,
+  TargetInstance,
+  AdapterInstance,
+  DriverInstance,
+  ExtensionInstance,
+} from '@prisma-next/contract/framework-components';
+
+// Component descriptors share common properties
+interface MyDescriptor extends ComponentDescriptor<'custom'> {
+  readonly customField: string;
+}
+
+// Use FamilyDescriptor for family components
+const sqlFamily: FamilyDescriptor<'sql'> = {
+  kind: 'family',
+  id: 'sql',
+  familyId: 'sql',
+  version: '0.0.1',
+};
+
+// Use TargetDescriptor for target components
+const postgresTarget: TargetDescriptor<'sql', 'postgres'> = {
+  kind: 'target',
+  id: 'postgres',
+  familyId: 'sql',
+  targetId: 'postgres',
+  version: '0.0.1',
+  capabilities: { postgres: { returning: true } },
+};
+
+// Identity instance bases are extended by plane-specific instances
+interface MySqlInstance extends FamilyInstance<'sql'> {
+  // Plane-specific methods...
+}
+```
+
+The component hierarchy is:
+
+```
+Family (e.g., 'sql', 'document')
+  └── Target (e.g., 'postgres', 'mysql', 'mongodb')
+        ├── Adapter (protocol/dialect implementation)
+        ├── Driver (connection/execution layer)
+        └── Extension (optional capabilities like pgvector)
+```
+
+Plane-specific descriptors (`ControlFamilyDescriptor`, `RuntimeTargetDescriptor`, etc.) extend these bases with plane-specific factory methods and capabilities.
+
 ### JSON Schema Validation
 
 Reference the appropriate JSON schema in your `contract.json` files to enable IDE validation and autocomplete.
@@ -144,7 +210,7 @@ All contracts share these common fields:
 - **`coreHash`** (required): SHA-256 hash of the core schema structure
 - **`profileHash`** (optional): SHA-256 hash of the capability profile
 - **`capabilities`** (optional): Capability flags declared by the contract
-- **`extensions`** (optional): Extension packs and their configuration
+- **`extensionPacks`** (optional): Extension packs and their configuration
 - **`meta`** (optional): Non-semantic metadata (excluded from hashing)
 - **`sources`** (optional): Read-only sources (views, etc.) available for querying
 
@@ -175,7 +241,10 @@ if (isDocumentContract(contract)) {
 
 ## Exports
 
-- `./types`: TypeScript type definitions and type guards
+- `./types`: Core contract type definitions, type guards, and emitter SPI types
+- `./framework-components`: Framework component model (descriptors + identity instance bases)
+- `./pack-manifest-types`: Extension pack manifest types
+- `./ir`: Contract IR types
 - `./schema-document`: Document family JSON Schema (`schemas/data-contract-document-v1.json`)
 
 ## Architecture

package/dist/exports/framework-components.d.ts

@@ -0,0 +1,412 @@
+import { TypesImportSpec, OperationManifest } from './types.js';
+import '@prisma-next/operations';
+import './ir.js';
+
+/**
+ * Declarative fields that describe component metadata.
+ * These fields are owned directly by descriptors (not nested under a manifest).
+ */
+interface ComponentMetadata {
+    /** Component version (semver) */
+    readonly version: string;
+    /**
+     * Capabilities this component provides.
+     *
+     * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into
+     * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);
+     * keep these declarations in sync. Targets are identifiers/descriptors and typically do not
+     * declare capabilities.
+     */
+    readonly capabilities?: Record<string, unknown>;
+    /** Type imports for contract.d.ts generation */
+    readonly types?: {
+        readonly codecTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly operationTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly storage?: ReadonlyArray<{
+            readonly typeId: string;
+            readonly familyId: string;
+            readonly targetId: string;
+            readonly nativeType?: string;
+        }>;
+    };
+    /** Operation manifests for building operation registries */
+    readonly operations?: ReadonlyArray<OperationManifest>;
+}
+/**
+ * Base descriptor for any framework component.
+ *
+ * All component descriptors share these fundamental properties that identify
+ * the component and provide its metadata. This interface is extended by
+ * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).
+ *
+ * @template Kind - Discriminator literal identifying the component type.
+ *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',
+ *   but the type accepts any string to allow ecosystem extensions.
+ *
+ * @example
+ * ```ts
+ * // All descriptors have these properties
+ * descriptor.kind     // The Kind type parameter (e.g., 'family', 'target', or custom kinds)
+ * descriptor.id       // Unique string identifier (e.g., 'sql', 'postgres')
+ * descriptor.version  // Component version (semver)
+ * ```
+ */
+interface ComponentDescriptor<Kind extends string> extends ComponentMetadata {
+    /** Discriminator identifying the component type */
+    readonly kind: Kind;
+    /** Unique identifier for this component (e.g., 'sql', 'postgres', 'pgvector') */
+    readonly id: string;
+}
+interface ContractComponentRequirementsCheckInput {
+    readonly contract: {
+        readonly target: string;
+        readonly targetFamily?: string | undefined;
+        readonly extensionPacks?: Record<string, unknown> | undefined;
+    };
+    readonly expectedTargetFamily?: string | undefined;
+    readonly expectedTargetId?: string | undefined;
+    readonly providedComponentIds: Iterable<string>;
+}
+interface ContractComponentRequirementsCheckResult {
+    readonly familyMismatch?: {
+        readonly expected: string;
+        readonly actual: string;
+    } | undefined;
+    readonly targetMismatch?: {
+        readonly expected: string;
+        readonly actual: string;
+    } | undefined;
+    readonly missingExtensionPackIds: readonly string[];
+}
+declare function checkContractComponentRequirements(input: ContractComponentRequirementsCheckInput): ContractComponentRequirementsCheckResult;
+/**
+ * Descriptor for a family component.
+ *
+ * A "family" represents a category of data sources with shared semantics
+ * (e.g., SQL databases, document stores). Families define:
+ * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)
+ * - Contract structure (tables vs collections, columns vs fields)
+ * - Type system and codecs
+ *
+ * Families are the top-level grouping. Each family contains multiple targets
+ * (e.g., SQL family contains Postgres, MySQL, SQLite targets).
+ *
+ * Extended by plane-specific descriptors:
+ * - `ControlFamilyDescriptor` - adds `hook` for CLI/tooling operations
+ * - `RuntimeFamilyDescriptor` - adds runtime-specific factory methods
+ *
+ * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')
+ *
+ * @example
+ * ```ts
+ * import sql from '@prisma-next/family-sql/control';
+ *
+ * sql.kind     // 'family'
+ * sql.familyId // 'sql'
+ * sql.id       // 'sql'
+ * ```
+ */
+interface FamilyDescriptor<TFamilyId extends string> extends ComponentDescriptor<'family'> {
+    /** The family identifier (e.g., 'sql', 'document') */
+    readonly familyId: TFamilyId;
+}
+/**
+ * Descriptor for a target component.
+ *
+ * A "target" represents a specific database or data store within a family
+ * (e.g., Postgres, MySQL, MongoDB). Targets define:
+ * - Native type mappings (e.g., Postgres int4 → TypeScript number)
+ * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)
+ *
+ * Targets are bound to a family and provide the target-specific implementation
+ * details that adapters and drivers use.
+ *
+ * Extended by plane-specific descriptors:
+ * - `ControlTargetDescriptor` - adds optional `migrations` capability
+ * - `RuntimeTargetDescriptor` - adds runtime factory method
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')
+ *
+ * @example
+ * ```ts
+ * import postgres from '@prisma-next/target-postgres/control';
+ *
+ * postgres.kind     // 'target'
+ * postgres.familyId // 'sql'
+ * postgres.targetId // 'postgres'
+ * ```
+ */
+interface TargetDescriptor<TFamilyId extends string, TTargetId extends string> extends ComponentDescriptor<'target'> {
+    /** The family this target belongs to */
+    readonly familyId: TFamilyId;
+    /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */
+    readonly targetId: TTargetId;
+}
+/**
+ * Base shape for any pack reference.
+ * Pack refs are pure JSON-friendly objects safe to import in authoring flows.
+ */
+interface PackRefBase<Kind extends string, TFamilyId extends string> extends ComponentMetadata {
+    readonly kind: Kind;
+    readonly id: string;
+    readonly familyId: TFamilyId;
+    readonly targetId?: string;
+}
+type TargetPackRef<TFamilyId extends string = string, TTargetId extends string = string> = PackRefBase<'target', TFamilyId> & {
+    readonly targetId: TTargetId;
+};
+type AdapterPackRef<TFamilyId extends string = string, TTargetId extends string = string> = PackRefBase<'adapter', TFamilyId> & {
+    readonly targetId: TTargetId;
+};
+type ExtensionPackRef<TFamilyId extends string = string, TTargetId extends string = string> = PackRefBase<'extension', TFamilyId> & {
+    readonly targetId: TTargetId;
+};
+type DriverPackRef<TFamilyId extends string = string, TTargetId extends string = string> = PackRefBase<'driver', TFamilyId> & {
+    readonly targetId: TTargetId;
+};
+/**
+ * Descriptor for an adapter component.
+ *
+ * An "adapter" provides the protocol and dialect implementation for a target.
+ * Adapters handle:
+ * - SQL/query generation (lowering AST to target-specific syntax)
+ * - Codec registration (encoding/decoding between JS and wire types)
+ * - Type mappings and coercions
+ *
+ * Adapters are bound to a specific family+target combination and work with
+ * any compatible driver for that target.
+ *
+ * Extended by plane-specific descriptors:
+ * - `ControlAdapterDescriptor` - control-plane factory
+ * - `RuntimeAdapterDescriptor` - runtime factory
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * import postgresAdapter from '@prisma-next/adapter-postgres/control';
+ *
+ * postgresAdapter.kind     // 'adapter'
+ * postgresAdapter.familyId // 'sql'
+ * postgresAdapter.targetId // 'postgres'
+ * ```
+ */
+interface AdapterDescriptor<TFamilyId extends string, TTargetId extends string> extends ComponentDescriptor<'adapter'> {
+    /** The family this adapter belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this adapter is designed for */
+    readonly targetId: TTargetId;
+}
+/**
+ * Descriptor for a driver component.
+ *
+ * A "driver" provides the connection and execution layer for a target.
+ * Drivers handle:
+ * - Connection management (pooling, timeouts, retries)
+ * - Query execution (sending SQL/commands, receiving results)
+ * - Transaction management
+ * - Wire protocol communication
+ *
+ * Drivers are bound to a specific family+target and work with any compatible
+ * adapter. Multiple drivers can exist for the same target (e.g., node-postgres
+ * vs postgres.js for Postgres).
+ *
+ * Extended by plane-specific descriptors:
+ * - `ControlDriverDescriptor` - creates driver from connection URL
+ * - `RuntimeDriverDescriptor` - creates driver with runtime options
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * import postgresDriver from '@prisma-next/driver-postgres/control';
+ *
+ * postgresDriver.kind     // 'driver'
+ * postgresDriver.familyId // 'sql'
+ * postgresDriver.targetId // 'postgres'
+ * ```
+ */
+interface DriverDescriptor<TFamilyId extends string, TTargetId extends string> extends ComponentDescriptor<'driver'> {
+    /** The family this driver belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this driver connects to */
+    readonly targetId: TTargetId;
+}
+/**
+ * Descriptor for an extension component.
+ *
+ * An "extension" adds optional capabilities to a target. Extensions can provide:
+ * - Additional operations (e.g., vector similarity search with pgvector)
+ * - Custom types and codecs (e.g., vector type)
+ * - Extended query capabilities
+ *
+ * Extensions are bound to a specific family+target and are registered in the
+ * config alongside the core components. Multiple extensions can be used together.
+ *
+ * Extended by plane-specific descriptors:
+ * - `ControlExtensionDescriptor` - control-plane extension factory
+ * - `RuntimeExtensionDescriptor` - runtime extension factory
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * import pgvector from '@prisma-next/extension-pgvector/control';
+ *
+ * pgvector.kind     // 'extension'
+ * pgvector.familyId // 'sql'
+ * pgvector.targetId // 'postgres'
+ * ```
+ */
+interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends string> extends ComponentDescriptor<'extension'> {
+    /** The family this extension belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this extension is designed for */
+    readonly targetId: TTargetId;
+}
+/**
+ * Union type for target-bound component descriptors.
+ *
+ * Target-bound components are those that must be compatible with a specific
+ * family+target combination. This includes targets, adapters, drivers, and
+ * extensions. Families are not target-bound.
+ *
+ * This type is used in migration and verification interfaces to enforce
+ * type-level compatibility between components.
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * // All these components must have matching familyId and targetId
+ * const components: TargetBoundComponentDescriptor<'sql', 'postgres'>[] = [
+ *   postgresTarget,
+ *   postgresAdapter,
+ *   postgresDriver,
+ *   pgvectorExtension,
+ * ];
+ * ```
+ */
+type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> = TargetDescriptor<TFamilyId, TTargetId> | AdapterDescriptor<TFamilyId, TTargetId> | DriverDescriptor<TFamilyId, TTargetId> | ExtensionDescriptor<TFamilyId, TTargetId>;
+/**
+ * Base interface for family instances.
+ *
+ * A family instance is created by a family descriptor's `create()` method.
+ * This base interface carries only the identity; plane-specific interfaces
+ * add domain actions (e.g., `emitContract`, `verify` on ControlFamilyInstance).
+ *
+ * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')
+ *
+ * @example
+ * ```ts
+ * const instance = sql.create({ target, adapter, driver, extensions });
+ * instance.familyId // 'sql'
+ * ```
+ */
+interface FamilyInstance<TFamilyId extends string> {
+    /** The family identifier (e.g., 'sql', 'document') */
+    readonly familyId: TFamilyId;
+}
+/**
+ * Base interface for target instances.
+ *
+ * A target instance is created by a target descriptor's `create()` method.
+ * This base interface carries only the identity; plane-specific interfaces
+ * add target-specific behavior.
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')
+ *
+ * @example
+ * ```ts
+ * const instance = postgres.create();
+ * instance.familyId // 'sql'
+ * instance.targetId // 'postgres'
+ * ```
+ */
+interface TargetInstance<TFamilyId extends string, TTargetId extends string> {
+    /** The family this target belongs to */
+    readonly familyId: TFamilyId;
+    /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */
+    readonly targetId: TTargetId;
+}
+/**
+ * Base interface for adapter instances.
+ *
+ * An adapter instance is created by an adapter descriptor's `create()` method.
+ * This base interface carries only the identity; plane-specific interfaces
+ * add adapter-specific behavior (e.g., codec registration, query lowering).
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * const instance = postgresAdapter.create();
+ * instance.familyId // 'sql'
+ * instance.targetId // 'postgres'
+ * ```
+ */
+interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {
+    /** The family this adapter belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this adapter is designed for */
+    readonly targetId: TTargetId;
+}
+/**
+ * Base interface for driver instances.
+ *
+ * A driver instance is created by a driver descriptor's `create()` method.
+ * This base interface carries only the identity; plane-specific interfaces
+ * add driver-specific behavior (e.g., `query`, `close` on ControlDriverInstance).
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * const instance = postgresDriver.create({ databaseUrl });
+ * instance.familyId // 'sql'
+ * instance.targetId // 'postgres'
+ * ```
+ */
+interface DriverInstance<TFamilyId extends string, TTargetId extends string> {
+    /** The family this driver belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this driver connects to */
+    readonly targetId: TTargetId;
+}
+/**
+ * Base interface for extension instances.
+ *
+ * An extension instance is created by an extension descriptor's `create()` method.
+ * This base interface carries only the identity; plane-specific interfaces
+ * add extension-specific behavior.
+ *
+ * @template TFamilyId - Literal type for the family identifier
+ * @template TTargetId - Literal type for the target identifier
+ *
+ * @example
+ * ```ts
+ * const instance = pgvector.create();
+ * instance.familyId // 'sql'
+ * instance.targetId // 'postgres'
+ * ```
+ */
+interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {
+    /** The family this extension belongs to */
+    readonly familyId: TFamilyId;
+    /** The target this extension is designed for */
+    readonly targetId: TTargetId;
+}
+
+export { type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type DriverDescriptor, type DriverInstance, type DriverPackRef, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type PackRefBase, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetPackRef, checkContractComponentRequirements };

package/dist/exports/framework-components.js

@@ -0,0 +1,24 @@
+// src/framework-components.ts
+function checkContractComponentRequirements(input) {
+  const providedIds = /* @__PURE__ */ new Set();
+  for (const id of input.providedComponentIds) {
+    providedIds.add(id);
+  }
+  const requiredExtensionPackIds = input.contract.extensionPacks ? Object.keys(input.contract.extensionPacks) : [];
+  const missingExtensionPackIds = requiredExtensionPackIds.filter((id) => !providedIds.has(id));
+  const expectedTargetFamily = input.expectedTargetFamily;
+  const contractTargetFamily = input.contract.targetFamily;
+  const familyMismatch = expectedTargetFamily !== void 0 && contractTargetFamily !== void 0 && contractTargetFamily !== expectedTargetFamily ? { expected: expectedTargetFamily, actual: contractTargetFamily } : void 0;
+  const expectedTargetId = input.expectedTargetId;
+  const contractTargetId = input.contract.target;
+  const targetMismatch = expectedTargetId !== void 0 && contractTargetId !== expectedTargetId ? { expected: expectedTargetId, actual: contractTargetId } : void 0;
+  return {
+    ...familyMismatch ? { familyMismatch } : {},
+    ...targetMismatch ? { targetMismatch } : {},
+    missingExtensionPackIds
+  };
+}
+export {
+  checkContractComponentRequirements
+};
+//# sourceMappingURL=framework-components.js.map

package/dist/exports/framework-components.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/framework-components.ts"],"sourcesContent":["import type { OperationManifest, TypesImportSpec } from './types';\n\n// ============================================================================\n// Framework Component Descriptor Base Types\n// ============================================================================\n//\n// Prisma Next uses a modular architecture where functionality is composed from\n// discrete \"components\". Each component has a descriptor that identifies it and\n// provides metadata. These base types define the shared structure for all\n// component descriptors across both control-plane (CLI/tooling) and runtime-plane.\n//\n// Component Hierarchy:\n//\n//   Family (e.g., 'sql', 'document')\n//     └── Target (e.g., 'postgres', 'mysql', 'mongodb')\n//           ├── Adapter (protocol/dialect implementation)\n//           ├── Driver (connection/execution layer)\n//           └── Extension (optional capabilities like pgvector)\n//\n// Key design decisions:\n// - \"Component\" terminology separates framework building blocks from delivery\n//   mechanism (\"pack\" refers to how components are packaged/distributed)\n// - `kind` is extensible (Kind extends string) - no closed union, allowing\n//   ecosystem authors to define new component kinds\n// - Target-bound descriptors are generic in TFamilyId and TTargetId for type-safe\n//   composition (e.g., TypeScript rejects Postgres adapter with MySQL target)\n// - Descriptors own declarative fields directly (version, types, operations, etc.)\n//   rather than nesting them under a `manifest` property\n//\n// ============================================================================\n\n/**\n * Declarative fields that describe component metadata.\n * These fields are owned directly by descriptors (not nested under a manifest).\n */\nexport interface ComponentMetadata {\n  /** Component version (semver) */\n  readonly version: string;\n\n  /**\n   * Capabilities this component provides.\n   *\n   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into\n   * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);\n   * keep these declarations in sync. Targets are identifiers/descriptors and typically do not\n   * declare capabilities.\n   */\n  readonly capabilities?: Record<string, unknown>;\n\n  /** Type imports for contract.d.ts generation */\n  readonly types?: {\n    readonly codecTypes?: { readonly import: TypesImportSpec };\n    readonly operationTypes?: { readonly import: TypesImportSpec };\n    readonly storage?: ReadonlyArray<{\n      readonly typeId: string;\n      readonly familyId: string;\n      readonly targetId: string;\n      readonly nativeType?: string;\n    }>;\n  };\n\n  /** Operation manifests for building operation registries */\n  readonly operations?: ReadonlyArray<OperationManifest>;\n}\n\n/**\n * Base descriptor for any framework component.\n *\n * All component descriptors share these fundamental properties that identify\n * the component and provide its metadata. This interface is extended by\n * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).\n *\n * @template Kind - Discriminator literal identifying the component type.\n *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',\n *   but the type accepts any string to allow ecosystem extensions.\n *\n * @example\n * ```ts\n * // All descriptors have these properties\n * descriptor.kind     // The Kind type parameter (e.g., 'family', 'target', or custom kinds)\n * descriptor.id       // Unique string identifier (e.g., 'sql', 'postgres')\n * descriptor.version  // Component version (semver)\n * ```\n */\nexport interface ComponentDescriptor<Kind extends string> extends ComponentMetadata {\n  /** Discriminator identifying the component type */\n  readonly kind: Kind;\n\n  /** Unique identifier for this component (e.g., 'sql', 'postgres', 'pgvector') */\n  readonly id: string;\n}\n\nexport interface ContractComponentRequirementsCheckInput {\n  readonly contract: {\n    readonly target: string;\n    readonly targetFamily?: string | undefined;\n    readonly extensionPacks?: Record<string, unknown> | undefined;\n  };\n  readonly expectedTargetFamily?: string | undefined;\n  readonly expectedTargetId?: string | undefined;\n  readonly providedComponentIds: Iterable<string>;\n}\n\nexport interface ContractComponentRequirementsCheckResult {\n  readonly familyMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly targetMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly missingExtensionPackIds: readonly string[];\n}\n\nexport function checkContractComponentRequirements(\n  input: ContractComponentRequirementsCheckInput,\n): ContractComponentRequirementsCheckResult {\n  const providedIds = new Set<string>();\n  for (const id of input.providedComponentIds) {\n    providedIds.add(id);\n  }\n\n  const requiredExtensionPackIds = input.contract.extensionPacks\n    ? Object.keys(input.contract.extensionPacks)\n    : [];\n  const missingExtensionPackIds = requiredExtensionPackIds.filter((id) => !providedIds.has(id));\n\n  const expectedTargetFamily = input.expectedTargetFamily;\n  const contractTargetFamily = input.contract.targetFamily;\n  const familyMismatch =\n    expectedTargetFamily !== undefined &&\n    contractTargetFamily !== undefined &&\n    contractTargetFamily !== expectedTargetFamily\n      ? { expected: expectedTargetFamily, actual: contractTargetFamily }\n      : undefined;\n\n  const expectedTargetId = input.expectedTargetId;\n  const contractTargetId = input.contract.target;\n  const targetMismatch =\n    expectedTargetId !== undefined && contractTargetId !== expectedTargetId\n      ? { expected: expectedTargetId, actual: contractTargetId }\n      : undefined;\n\n  return {\n    ...(familyMismatch ? { familyMismatch } : {}),\n    ...(targetMismatch ? { targetMismatch } : {}),\n    missingExtensionPackIds,\n  };\n}\n\n/**\n * Descriptor for a family component.\n *\n * A \"family\" represents a category of data sources with shared semantics\n * (e.g., SQL databases, document stores). Families define:\n * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)\n * - Contract structure (tables vs collections, columns vs fields)\n * - Type system and codecs\n *\n * Families are the top-level grouping. Each family contains multiple targets\n * (e.g., SQL family contains Postgres, MySQL, SQLite targets).\n *\n * Extended by plane-specific descriptors:\n * - `ControlFamilyDescriptor` - adds `hook` for CLI/tooling operations\n * - `RuntimeFamilyDescriptor` - adds runtime-specific factory methods\n *\n * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')\n *\n * @example\n * ```ts\n * import sql from '@prisma-next/family-sql/control';\n *\n * sql.kind     // 'family'\n * sql.familyId // 'sql'\n * sql.id       // 'sql'\n * ```\n */\nexport interface FamilyDescriptor<TFamilyId extends string> extends ComponentDescriptor<'family'> {\n  /** The family identifier (e.g., 'sql', 'document') */\n  readonly familyId: TFamilyId;\n}\n\n/**\n * Descriptor for a target component.\n *\n * A \"target\" represents a specific database or data store within a family\n * (e.g., Postgres, MySQL, MongoDB). Targets define:\n * - Native type mappings (e.g., Postgres int4 → TypeScript number)\n * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)\n *\n * Targets are bound to a family and provide the target-specific implementation\n * details that adapters and drivers use.\n *\n * Extended by plane-specific descriptors:\n * - `ControlTargetDescriptor` - adds optional `migrations` capability\n * - `RuntimeTargetDescriptor` - adds runtime factory method\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')\n *\n * @example\n * ```ts\n * import postgres from '@prisma-next/target-postgres/control';\n *\n * postgres.kind     // 'target'\n * postgres.familyId // 'sql'\n * postgres.targetId // 'postgres'\n * ```\n */\nexport interface TargetDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'target'> {\n  /** The family this target belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base shape for any pack reference.\n * Pack refs are pure JSON-friendly objects safe to import in authoring flows.\n */\nexport interface PackRefBase<Kind extends string, TFamilyId extends string>\n  extends ComponentMetadata {\n  readonly kind: Kind;\n  readonly id: string;\n  readonly familyId: TFamilyId;\n  readonly targetId?: string;\n}\n\nexport type TargetPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'target', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type AdapterPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'adapter', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type ExtensionPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'extension', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type DriverPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'driver', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\n/**\n * Descriptor for an adapter component.\n *\n * An \"adapter\" provides the protocol and dialect implementation for a target.\n * Adapters handle:\n * - SQL/query generation (lowering AST to target-specific syntax)\n * - Codec registration (encoding/decoding between JS and wire types)\n * - Type mappings and coercions\n *\n * Adapters are bound to a specific family+target combination and work with\n * any compatible driver for that target.\n *\n * Extended by plane-specific descriptors:\n * - `ControlAdapterDescriptor` - control-plane factory\n * - `RuntimeAdapterDescriptor` - runtime factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresAdapter from '@prisma-next/adapter-postgres/control';\n *\n * postgresAdapter.kind     // 'adapter'\n * postgresAdapter.familyId // 'sql'\n * postgresAdapter.targetId // 'postgres'\n * ```\n */\nexport interface AdapterDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'adapter'> {\n  /** The family this adapter belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this adapter is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for a driver component.\n *\n * A \"driver\" provides the connection and execution layer for a target.\n * Drivers handle:\n * - Connection management (pooling, timeouts, retries)\n * - Query execution (sending SQL/commands, receiving results)\n * - Transaction management\n * - Wire protocol communication\n *\n * Drivers are bound to a specific family+target and work with any compatible\n * adapter. Multiple drivers can exist for the same target (e.g., node-postgres\n * vs postgres.js for Postgres).\n *\n * Extended by plane-specific descriptors:\n * - `ControlDriverDescriptor` - creates driver from connection URL\n * - `RuntimeDriverDescriptor` - creates driver with runtime options\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresDriver from '@prisma-next/driver-postgres/control';\n *\n * postgresDriver.kind     // 'driver'\n * postgresDriver.familyId // 'sql'\n * postgresDriver.targetId // 'postgres'\n * ```\n */\nexport interface DriverDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'driver'> {\n  /** The family this driver belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this driver connects to */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for an extension component.\n *\n * An \"extension\" adds optional capabilities to a target. Extensions can provide:\n * - Additional operations (e.g., vector similarity search with pgvector)\n * - Custom types and codecs (e.g., vector type)\n * - Extended query capabilities\n *\n * Extensions are bound to a specific family+target and are registered in the\n * config alongside the core components. Multiple extensions can be used together.\n *\n * Extended by plane-specific descriptors:\n * - `ControlExtensionDescriptor` - control-plane extension factory\n * - `RuntimeExtensionDescriptor` - runtime extension factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import pgvector from '@prisma-next/extension-pgvector/control';\n *\n * pgvector.kind     // 'extension'\n * pgvector.familyId // 'sql'\n * pgvector.targetId // 'postgres'\n * ```\n */\nexport interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'extension'> {\n  /** The family this extension belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this extension is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Union type for target-bound component descriptors.\n *\n * Target-bound components are those that must be compatible with a specific\n * family+target combination. This includes targets, adapters, drivers, and\n * extensions. Families are not target-bound.\n *\n * This type is used in migration and verification interfaces to enforce\n * type-level compatibility between components.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * // All these components must have matching familyId and targetId\n * const components: TargetBoundComponentDescriptor<'sql', 'postgres'>[] = [\n *   postgresTarget,\n *   postgresAdapter,\n *   postgresDriver,\n *   pgvectorExtension,\n * ];\n * ```\n */\nexport type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> =\n  | TargetDescriptor<TFamilyId, TTargetId>\n  | AdapterDescriptor<TFamilyId, TTargetId>\n  | DriverDescriptor<TFamilyId, TTargetId>\n  | ExtensionDescriptor<TFamilyId, TTargetId>;\n\n// ============================================================================\n// Framework Component Instance Base Types\n// ============================================================================\n//\n// These are minimal, identity-only interfaces for component instances.\n// They carry the component's identity (familyId, targetId) without any\n// behavior methods. Plane-specific interfaces (ControlFamilyInstance,\n// RuntimeFamilyInstance, etc.) extend these bases and add domain actions.\n//\n// ============================================================================\n\n/**\n * Base interface for family instances.\n *\n * A family instance is created by a family descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add domain actions (e.g., `emitContract`, `verify` on ControlFamilyInstance).\n *\n * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')\n *\n * @example\n * ```ts\n * const instance = sql.create({ target, adapter, driver, extensions });\n * instance.familyId // 'sql'\n * ```\n */\nexport interface FamilyInstance<TFamilyId extends string> {\n  /** The family identifier (e.g., 'sql', 'document') */\n  readonly familyId: TFamilyId;\n}\n\n/**\n * Base interface for target instances.\n *\n * A target instance is created by a target descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add target-specific behavior.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')\n *\n * @example\n * ```ts\n * const instance = postgres.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface TargetInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this target belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for adapter instances.\n *\n * An adapter instance is created by an adapter descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add adapter-specific behavior (e.g., codec registration, query lowering).\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = postgresAdapter.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this adapter belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this adapter is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for driver instances.\n *\n * A driver instance is created by a driver descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add driver-specific behavior (e.g., `query`, `close` on ControlDriverInstance).\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = postgresDriver.create({ databaseUrl });\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface DriverInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this driver belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this driver connects to */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for extension instances.\n *\n * An extension instance is created by an extension descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add extension-specific behavior.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = pgvector.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this extension belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this extension is designed for */\n  readonly targetId: TTargetId;\n}\n"],"mappings":";AA6GO,SAAS,mCACd,OAC0C;AAC1C,QAAM,cAAc,oBAAI,IAAY;AACpC,aAAW,MAAM,MAAM,sBAAsB;AAC3C,gBAAY,IAAI,EAAE;AAAA,EACpB;AAEA,QAAM,2BAA2B,MAAM,SAAS,iBAC5C,OAAO,KAAK,MAAM,SAAS,cAAc,IACzC,CAAC;AACL,QAAM,0BAA0B,yBAAyB,OAAO,CAAC,OAAO,CAAC,YAAY,IAAI,EAAE,CAAC;AAE5F,QAAM,uBAAuB,MAAM;AACnC,QAAM,uBAAuB,MAAM,SAAS;AAC5C,QAAM,iBACJ,yBAAyB,UACzB,yBAAyB,UACzB,yBAAyB,uBACrB,EAAE,UAAU,sBAAsB,QAAQ,qBAAqB,IAC/D;AAEN,QAAM,mBAAmB,MAAM;AAC/B,QAAM,mBAAmB,MAAM,SAAS;AACxC,QAAM,iBACJ,qBAAqB,UAAa,qBAAqB,mBACnD,EAAE,UAAU,kBAAkB,QAAQ,iBAAiB,IACvD;AAEN,SAAO;AAAA,IACL,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;AAAA,IAC3C,GAAI,iBAAiB,EAAE,eAAe,IAAI,CAAC;AAAA,IAC3C;AAAA,EACF;AACF;","names":[]}

package/dist/exports/ir.d.ts

@@ -14,7 +14,7 @@ interface ContractIR<TStorage extends Record<string, unknown> = Record<string, u
     readonly models: TModels;
     readonly relations: TRelations;
     readonly storage: TStorage;
-    readonly extensions: Record<string, unknown>;
+    readonly extensionPacks: Record<string, unknown>;
     readonly capabilities: Record<string, Record<string, boolean>>;
     readonly meta: Record<string, unknown>;
     readonly sources: Record<string, unknown>;
@@ -37,17 +37,17 @@ declare function irHeader(opts: {
 };
 /**
  * Creates the meta portion of a ContractIR.
- * Contains capabilities, extensions, meta, and sources with empty object defaults.
+ * Contains capabilities, extensionPacks, meta, and sources with empty object defaults.
  * If a field is explicitly `undefined`, it will be omitted (for testing validation).
  */
 declare function irMeta(opts?: {
     capabilities?: Record<string, Record<string, boolean>> | undefined;
-    extensions?: Record<string, unknown> | undefined;
+    extensionPacks?: Record<string, unknown> | undefined;
     meta?: Record<string, unknown> | undefined;
     sources?: Record<string, unknown> | undefined;
 }): {
     readonly capabilities: Record<string, Record<string, boolean>>;
-    readonly extensions: Record<string, unknown>;
+    readonly extensionPacks: Record<string, unknown>;
     readonly meta: Record<string, unknown>;
     readonly sources: Record<string, unknown>;
 };
@@ -65,7 +65,7 @@ declare function contractIR<TStorage extends Record<string, unknown>, TModels ex
     };
     meta: {
         readonly capabilities: Record<string, Record<string, boolean>>;
-        readonly extensions: Record<string, unknown>;
+        readonly extensionPacks: Record<string, unknown>;
         readonly meta: Record<string, unknown>;
         readonly sources: Record<string, unknown>;
     };

package/dist/exports/ir.js

@@ -11,7 +11,7 @@ function irHeader(opts) {
 function irMeta(opts) {
   return {
     capabilities: opts?.capabilities ?? {},
-    extensions: opts?.extensions ?? {},
+    extensionPacks: opts?.extensionPacks ?? {},
     meta: opts?.meta ?? {},
     sources: opts?.sources ?? {}
   };

package/dist/exports/ir.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/ir.ts"],"sourcesContent":["/**\n * ContractIR types and factories for building contract intermediate representation.\n * ContractIR is family-agnostic and used by authoring, emitter, and no-emit runtime.\n */\n\n/**\n * ContractIR represents the intermediate representation of a contract.\n * It is family-agnostic and contains generic storage, models, and relations.\n * Note: coreHash and profileHash are computed by the emitter, not part of the IR.\n */\nexport interface ContractIR<\n  TStorage extends Record<string, unknown> = Record<string, unknown>,\n  TModels extends Record<string, unknown> = Record<string, unknown>,\n  TRelations extends Record<string, unknown> = Record<string, unknown>,\n> {\n  readonly schemaVersion: string;\n  readonly targetFamily: string;\n  readonly target: string;\n  readonly models: TModels;\n  readonly relations: TRelations;\n  readonly storage: TStorage;\n  readonly extensions: Record<string, unknown>;\n  readonly capabilities: Record<string, Record<string, boolean>>;\n  readonly meta: Record<string, unknown>;\n  readonly sources: Record<string, unknown>;\n}\n\n/**\n * Creates the header portion of a ContractIR.\n * Contains schema version, target, target family, core hash, and optional profile hash.\n */\nexport function irHeader(opts: {\n  target: string;\n  targetFamily: string;\n  coreHash: string;\n  profileHash?: string;\n}): {\n  readonly schemaVersion: string;\n  readonly target: string;\n  readonly targetFamily: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n} {\n  return {\n    schemaVersion: '1',\n    target: opts.target,\n    targetFamily: opts.targetFamily,\n    coreHash: opts.coreHash,\n    ...(opts.profileHash !== undefined && { profileHash: opts.profileHash }),\n  };\n}\n\n/**\n * Creates the meta portion of a ContractIR.\n * Contains capabilities, extensions, meta, and sources with empty object defaults.\n * If a field is explicitly `undefined`, it will be omitted (for testing validation).\n */\nexport function irMeta(opts?: {\n  capabilities?: Record<string, Record<string, boolean>> | undefined;\n  extensions?: Record<string, unknown> | undefined;\n  meta?: Record<string, unknown> | undefined;\n  sources?: Record<string, unknown> | undefined;\n}): {\n  readonly capabilities: Record<string, Record<string, boolean>>;\n  readonly extensions: Record<string, unknown>;\n  readonly meta: Record<string, unknown>;\n  readonly sources: Record<string, unknown>;\n} {\n  return {\n    capabilities: opts?.capabilities ?? {},\n    extensions: opts?.extensions ?? {},\n    meta: opts?.meta ?? {},\n    sources: opts?.sources ?? {},\n  };\n}\n\n/**\n * Creates a complete ContractIR by combining header, meta, and family-specific sections.\n * This is a family-agnostic factory that accepts generic storage, models, and relations.\n */\nexport function contractIR<\n  TStorage extends Record<string, unknown>,\n  TModels extends Record<string, unknown>,\n  TRelations extends Record<string, unknown>,\n>(opts: {\n  header: {\n    readonly schemaVersion: string;\n    readonly target: string;\n    readonly targetFamily: string;\n    readonly coreHash: string;\n    readonly profileHash?: string;\n  };\n  meta: {\n    readonly capabilities: Record<string, Record<string, boolean>>;\n    readonly extensions: Record<string, unknown>;\n    readonly meta: Record<string, unknown>;\n    readonly sources: Record<string, unknown>;\n  };\n  storage: TStorage;\n  models: TModels;\n  relations: TRelations;\n}): ContractIR<TStorage, TModels, TRelations> {\n  // ContractIR doesn't include coreHash or profileHash (those are computed by emitter)\n  return {\n    schemaVersion: opts.header.schemaVersion,\n    target: opts.header.target,\n    targetFamily: opts.header.targetFamily,\n    ...opts.meta,\n    storage: opts.storage,\n    models: opts.models,\n    relations: opts.relations,\n  };\n}\n"],"mappings":";AA+BO,SAAS,SAAS,MAWvB;AACA,SAAO;AAAA,IACL,eAAe;AAAA,IACf,QAAQ,KAAK;AAAA,IACb,cAAc,KAAK;AAAA,IACnB,UAAU,KAAK;AAAA,IACf,GAAI,KAAK,gBAAgB,UAAa,EAAE,aAAa,KAAK,YAAY;AAAA,EACxE;AACF;AAOO,SAAS,OAAO,MAUrB;AACA,SAAO;AAAA,IACL,cAAc,MAAM,gBAAgB,CAAC;AAAA,IACrC,YAAY,MAAM,cAAc,CAAC;AAAA,IACjC,MAAM,MAAM,QAAQ,CAAC;AAAA,IACrB,SAAS,MAAM,WAAW,CAAC;AAAA,EAC7B;AACF;AAMO,SAAS,WAId,MAiB4C;AAE5C,SAAO;AAAA,IACL,eAAe,KAAK,OAAO;AAAA,IAC3B,QAAQ,KAAK,OAAO;AAAA,IACpB,cAAc,KAAK,OAAO;AAAA,IAC1B,GAAG,KAAK;AAAA,IACR,SAAS,KAAK;AAAA,IACd,QAAQ,KAAK;AAAA,IACb,WAAW,KAAK;AAAA,EAClB;AACF;","names":[]}
+{"version":3,"sources":["../../src/ir.ts"],"sourcesContent":["/**\n * ContractIR types and factories for building contract intermediate representation.\n * ContractIR is family-agnostic and used by authoring, emitter, and no-emit runtime.\n */\n\n/**\n * ContractIR represents the intermediate representation of a contract.\n * It is family-agnostic and contains generic storage, models, and relations.\n * Note: coreHash and profileHash are computed by the emitter, not part of the IR.\n */\nexport interface ContractIR<\n  TStorage extends Record<string, unknown> = Record<string, unknown>,\n  TModels extends Record<string, unknown> = Record<string, unknown>,\n  TRelations extends Record<string, unknown> = Record<string, unknown>,\n> {\n  readonly schemaVersion: string;\n  readonly targetFamily: string;\n  readonly target: string;\n  readonly models: TModels;\n  readonly relations: TRelations;\n  readonly storage: TStorage;\n  readonly extensionPacks: Record<string, unknown>;\n  readonly capabilities: Record<string, Record<string, boolean>>;\n  readonly meta: Record<string, unknown>;\n  readonly sources: Record<string, unknown>;\n}\n\n/**\n * Creates the header portion of a ContractIR.\n * Contains schema version, target, target family, core hash, and optional profile hash.\n */\nexport function irHeader(opts: {\n  target: string;\n  targetFamily: string;\n  coreHash: string;\n  profileHash?: string;\n}): {\n  readonly schemaVersion: string;\n  readonly target: string;\n  readonly targetFamily: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n} {\n  return {\n    schemaVersion: '1',\n    target: opts.target,\n    targetFamily: opts.targetFamily,\n    coreHash: opts.coreHash,\n    ...(opts.profileHash !== undefined && { profileHash: opts.profileHash }),\n  };\n}\n\n/**\n * Creates the meta portion of a ContractIR.\n * Contains capabilities, extensionPacks, meta, and sources with empty object defaults.\n * If a field is explicitly `undefined`, it will be omitted (for testing validation).\n */\nexport function irMeta(opts?: {\n  capabilities?: Record<string, Record<string, boolean>> | undefined;\n  extensionPacks?: Record<string, unknown> | undefined;\n  meta?: Record<string, unknown> | undefined;\n  sources?: Record<string, unknown> | undefined;\n}): {\n  readonly capabilities: Record<string, Record<string, boolean>>;\n  readonly extensionPacks: Record<string, unknown>;\n  readonly meta: Record<string, unknown>;\n  readonly sources: Record<string, unknown>;\n} {\n  return {\n    capabilities: opts?.capabilities ?? {},\n    extensionPacks: opts?.extensionPacks ?? {},\n    meta: opts?.meta ?? {},\n    sources: opts?.sources ?? {},\n  };\n}\n\n/**\n * Creates a complete ContractIR by combining header, meta, and family-specific sections.\n * This is a family-agnostic factory that accepts generic storage, models, and relations.\n */\nexport function contractIR<\n  TStorage extends Record<string, unknown>,\n  TModels extends Record<string, unknown>,\n  TRelations extends Record<string, unknown>,\n>(opts: {\n  header: {\n    readonly schemaVersion: string;\n    readonly target: string;\n    readonly targetFamily: string;\n    readonly coreHash: string;\n    readonly profileHash?: string;\n  };\n  meta: {\n    readonly capabilities: Record<string, Record<string, boolean>>;\n    readonly extensionPacks: Record<string, unknown>;\n    readonly meta: Record<string, unknown>;\n    readonly sources: Record<string, unknown>;\n  };\n  storage: TStorage;\n  models: TModels;\n  relations: TRelations;\n}): ContractIR<TStorage, TModels, TRelations> {\n  // ContractIR doesn't include coreHash or profileHash (those are computed by emitter)\n  return {\n    schemaVersion: opts.header.schemaVersion,\n    target: opts.header.target,\n    targetFamily: opts.header.targetFamily,\n    ...opts.meta,\n    storage: opts.storage,\n    models: opts.models,\n    relations: opts.relations,\n  };\n}\n"],"mappings":";AA+BO,SAAS,SAAS,MAWvB;AACA,SAAO;AAAA,IACL,eAAe;AAAA,IACf,QAAQ,KAAK;AAAA,IACb,cAAc,KAAK;AAAA,IACnB,UAAU,KAAK;AAAA,IACf,GAAI,KAAK,gBAAgB,UAAa,EAAE,aAAa,KAAK,YAAY;AAAA,EACxE;AACF;AAOO,SAAS,OAAO,MAUrB;AACA,SAAO;AAAA,IACL,cAAc,MAAM,gBAAgB,CAAC;AAAA,IACrC,gBAAgB,MAAM,kBAAkB,CAAC;AAAA,IACzC,MAAM,MAAM,QAAQ,CAAC;AAAA,IACrB,SAAS,MAAM,WAAW,CAAC;AAAA,EAC7B;AACF;AAMO,SAAS,WAId,MAiB4C;AAE5C,SAAO;AAAA,IACL,eAAe,KAAK,OAAO;AAAA,IAC3B,QAAQ,KAAK,OAAO;AAAA,IACpB,cAAc,KAAK,OAAO;AAAA,IAC1B,GAAG,KAAK;AAAA,IACR,SAAS,KAAK;AAAA,IACd,QAAQ,KAAK;AAAA,IACb,WAAW,KAAK;AAAA,EAClB;AACF;","names":[]}

package/dist/exports/pack-manifest-types.d.ts

@@ -1,3 +1,3 @@
-export { A as ArgSpecManifest, E as ExtensionPack, a as ExtensionPackManifest, L as LoweringSpecManifest, O as OperationManifest, R as ReturnSpecManifest } from './types.js';
+export { A as ArgSpecManifest, L as LoweringSpecManifest, OperationManifest, R as ReturnSpecManifest } from './types.js';
 import '@prisma-next/operations';
 import './ir.js';

package/dist/exports/types.d.ts

@@ -8,7 +8,7 @@ interface ContractBase {
     readonly coreHash: string;
     readonly profileHash?: string;
     readonly capabilities?: Record<string, Record<string, boolean>>;
-    readonly extensions?: Record<string, unknown>;
+    readonly extensionPacks?: Record<string, unknown>;
     readonly meta?: Record<string, unknown>;
     readonly sources?: Record<string, Source>;
 }
@@ -173,7 +173,7 @@ interface ValidationContext {
 interface TargetFamilyHook {
     readonly id: string;
     /**
-     * Validates that all type IDs in the contract come from referenced extensions.
+     * Validates that all type IDs in the contract come from referenced extension packs.
      * @param ir - Contract IR to validate
      * @param ctx - Validation context with operation registry and extension IDs
      */
@@ -220,32 +220,5 @@ interface OperationManifest {
     readonly lowering: LoweringSpecManifest;
     readonly capabilities?: ReadonlyArray<string>;
 }
-interface ExtensionPackManifest {
-    readonly id: string;
-    readonly version: string;
-    readonly targets?: Record<string, {
-        readonly minVersion?: string;
-    }>;
-    readonly capabilities?: Record<string, unknown>;
-    readonly types?: {
-        readonly codecTypes?: {
-            readonly import: TypesImportSpec;
-        };
-        readonly operationTypes?: {
-            readonly import: TypesImportSpec;
-        };
-        readonly storage?: readonly {
-            readonly typeId: string;
-            readonly familyId: string;
-            readonly targetId: string;
-            readonly nativeType?: string;
-        }[];
-    };
-    readonly operations?: ReadonlyArray<OperationManifest>;
-}
-interface ExtensionPack {
-    readonly manifest: ExtensionPackManifest;
-    readonly path: string;
-}
 
-export { type ArgSpecManifest as A, type ContractBase, type ContractMarkerRecord, type DocCollection, type DocIndex, type DocumentContract, type DocumentStorage, type ExtensionPack as E, type ExecutionPlan, type Expr, type FieldType, type LoweringSpecManifest as L, type OperationManifest as O, type ParamDescriptor, type PlanMeta, type PlanRefs, type ReturnSpecManifest as R, type ResultType, type Source, type TargetFamilyHook, type TypesImportSpec, type ValidationContext, type ExtensionPackManifest as a, isDocumentContract };
+export { type ArgSpecManifest as A, type ContractBase, type ContractMarkerRecord, type DocCollection, type DocIndex, type DocumentContract, type DocumentStorage, type ExecutionPlan, type Expr, type FieldType, type LoweringSpecManifest as L, type OperationManifest, type ParamDescriptor, type PlanMeta, type PlanRefs, type ReturnSpecManifest as R, type ResultType, type Source, type TargetFamilyHook, type TypesImportSpec, type ValidationContext, isDocumentContract };

package/dist/exports/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport type { ContractIR } from './ir';\n\n// Shared header and neutral types\n// Note: Fields like targetFamily accept string to work with JSON imports,\n// which don't preserve literal types. Runtime validation ensures correct values\nexport interface ContractBase {\n  readonly schemaVersion: string;\n  readonly target: string;\n  readonly targetFamily: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n  readonly capabilities?: Record<string, Record<string, boolean>>;\n  readonly extensions?: Record<string, unknown>;\n  readonly meta?: Record<string, unknown>;\n  readonly sources?: Record<string, Source>;\n}\n\nexport interface FieldType {\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly items?: FieldType;\n  readonly properties?: Record<string, FieldType>;\n}\n\nexport interface Source {\n  readonly readOnly: boolean;\n  readonly projection: Record<string, FieldType>;\n  readonly origin?: Record<string, unknown>;\n  readonly capabilities?: Record<string, boolean>;\n}\n\n// Document family types\nexport interface DocIndex {\n  readonly name: string;\n  readonly keys: Record<string, 'asc' | 'desc'>;\n  readonly unique?: boolean;\n  readonly where?: Expr;\n}\n\nexport type Expr =\n  | { readonly kind: 'eq'; readonly path: ReadonlyArray<string>; readonly value: unknown }\n  | { readonly kind: 'exists'; readonly path: ReadonlyArray<string> };\n\nexport interface DocCollection {\n  readonly name: string;\n  readonly id?: {\n    readonly strategy: 'auto' | 'client' | 'uuid' | 'cuid' | 'objectId';\n  };\n  readonly fields: Record<string, FieldType>;\n  readonly indexes?: ReadonlyArray<DocIndex>;\n  readonly readOnly?: boolean;\n}\n\nexport interface DocumentStorage {\n  readonly document: {\n    readonly collections: Record<string, DocCollection>;\n  };\n}\n\nexport interface DocumentContract extends ContractBase {\n  // Accept string to work with JSON imports; runtime validation ensures 'document'\n  readonly targetFamily: string;\n  readonly storage: DocumentStorage;\n}\n\n// Plan types - target-family agnostic execution types\nexport interface ParamDescriptor {\n  readonly index?: number;\n  readonly name?: string;\n  readonly codecId?: string;\n  readonly nativeType?: string;\n  readonly nullable?: boolean;\n  readonly source: 'dsl' | 'raw';\n  readonly refs?: { table: string; column: string };\n}\n\nexport interface PlanRefs {\n  readonly tables?: readonly string[];\n  readonly columns?: ReadonlyArray<{ table: string; column: string }>;\n  readonly indexes?: ReadonlyArray<{\n    readonly table: string;\n    readonly columns: ReadonlyArray<string>;\n    readonly name?: string;\n  }>;\n}\n\nexport interface PlanMeta {\n  readonly target: string;\n  readonly targetFamily?: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n  readonly lane: string;\n  readonly annotations?: {\n    codecs?: Record<string, string>; // alias/param → codec id ('ns/name@v')\n    [key: string]: unknown;\n  };\n  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;\n  readonly refs?: PlanRefs;\n  readonly projection?: Record<string, string> | ReadonlyArray<string>;\n  /**\n   * Optional mapping of projection alias → column type ID (fully qualified ns/name@version).\n   * Used for codec resolution when AST+refs don't provide enough type info.\n   */\n  readonly projectionTypes?: Record<string, string>;\n}\n\n/**\n * Canonical execution plan shape used by runtimes.\n *\n * - Row is the inferred result row type (TypeScript-only).\n * - Ast is the optional, family-specific AST type (e.g. SQL QueryAst).\n *\n * The payload executed by the runtime is represented by the sql + params pair\n * for now; future families can specialize this via Ast or additional metadata.\n */\nexport interface ExecutionPlan<Row = unknown, Ast = unknown> {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly ast?: Ast;\n  readonly meta: PlanMeta;\n  /**\n   * Phantom property to carry the Row generic for type-level utilities.\n   * Not set at runtime; used only for ResultType extraction.\n   */\n  readonly _row?: Row;\n}\n\n/**\n * Utility type to extract the Row type from an ExecutionPlan.\n * Example: `type Row = ResultType<typeof plan>`\n *\n * Works with both ExecutionPlan and SqlQueryPlan (SQL query plans before lowering).\n * SqlQueryPlan includes a phantom `_Row` property to preserve the generic parameter\n * for type extraction.\n */\nexport type ResultType<P> = P extends ExecutionPlan<infer R, unknown>\n  ? R\n  : P extends { readonly _Row?: infer R }\n    ? R\n    : never;\n\n/**\n * Type guard to check if a contract is a Document contract\n */\nexport function isDocumentContract(contract: unknown): contract is DocumentContract {\n  return (\n    typeof contract === 'object' &&\n    contract !== null &&\n    'targetFamily' in contract &&\n    contract.targetFamily === 'document'\n  );\n}\n\n/**\n * Contract marker record stored in the database.\n * Represents the current contract identity for a database.\n */\nexport interface ContractMarkerRecord {\n  readonly coreHash: string;\n  readonly profileHash: string;\n  readonly contractJson: unknown | null;\n  readonly canonicalVersion: number | null;\n  readonly updatedAt: Date;\n  readonly appTag: string | null;\n  readonly meta: Record<string, unknown>;\n}\n\n// Emitter types - moved from @prisma-next/emitter to shared location\n/**\n * Specifies how to import TypeScript types from a package.\n * Used in extension pack manifests to declare codec and operation type imports.\n */\nexport interface TypesImportSpec {\n  readonly package: string;\n  readonly named: string;\n  readonly alias: string;\n}\n\n/**\n * Validation context passed to TargetFamilyHook.validateTypes().\n * Contains pre-assembled operation registry, type imports, and extension IDs.\n */\nexport interface ValidationContext {\n  readonly operationRegistry?: OperationRegistry;\n  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly extensionIds?: ReadonlyArray<string>;\n}\n\n/**\n * SPI interface for target family hooks that extend emission behavior.\n * Implemented by family-specific emitter hooks (e.g., SQL family).\n */\nexport interface TargetFamilyHook {\n  readonly id: string;\n\n  /**\n   * Validates that all type IDs in the contract come from referenced extensions.\n   * @param ir - Contract IR to validate\n   * @param ctx - Validation context with operation registry and extension IDs\n   */\n  validateTypes(ir: ContractIR, ctx: ValidationContext): void;\n\n  /**\n   * Validates family-specific contract structure.\n   * @param ir - Contract IR to validate\n   */\n  validateStructure(ir: ContractIR): void;\n\n  /**\n   * Generates contract.d.ts file content.\n   * @param ir - Contract IR\n   * @param codecTypeImports - Array of codec type import specs\n   * @param operationTypeImports - Array of operation type import specs\n   * @returns Generated TypeScript type definitions as string\n   */\n  generateContractTypes(\n    ir: ContractIR,\n    codecTypeImports: ReadonlyArray<TypesImportSpec>,\n    operationTypeImports: ReadonlyArray<TypesImportSpec>,\n  ): string;\n}\n\n// Extension pack manifest types - moved from @prisma-next/core-control-plane to shared location\nexport type ArgSpecManifest =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'param' }\n  | { readonly kind: 'literal' };\n\nexport type ReturnSpecManifest =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'builtin'; readonly type: 'number' | 'boolean' | 'string' };\n\nexport interface LoweringSpecManifest {\n  readonly targetFamily: 'sql';\n  readonly strategy: 'infix' | 'function';\n  readonly template: string;\n}\n\nexport interface OperationManifest {\n  readonly for: string;\n  readonly method: string;\n  readonly args: ReadonlyArray<ArgSpecManifest>;\n  readonly returns: ReturnSpecManifest;\n  readonly lowering: LoweringSpecManifest;\n  readonly capabilities?: ReadonlyArray<string>;\n}\n\nexport interface ExtensionPackManifest {\n  readonly id: string;\n  readonly version: string;\n  readonly targets?: Record<string, { readonly minVersion?: string }>;\n  readonly capabilities?: Record<string, unknown>;\n  readonly types?: {\n    readonly codecTypes?: {\n      readonly import: TypesImportSpec;\n    };\n    readonly operationTypes?: {\n      readonly import: TypesImportSpec;\n    };\n    readonly storage?: readonly {\n      readonly typeId: string;\n      readonly familyId: string;\n      readonly targetId: string;\n      readonly nativeType?: string;\n    }[];\n  };\n  readonly operations?: ReadonlyArray<OperationManifest>;\n}\n\nexport interface ExtensionPack {\n  readonly manifest: ExtensionPackManifest;\n  readonly path: string;\n}\n"],"mappings":";AAiJO,SAAS,mBAAmB,UAAiD;AAClF,SACE,OAAO,aAAa,YACpB,aAAa,QACb,kBAAkB,YAClB,SAAS,iBAAiB;AAE9B;","names":[]}
+{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import type { OperationRegistry } from '@prisma-next/operations';\nimport type { ContractIR } from './ir';\n\nexport interface ContractBase {\n  readonly schemaVersion: string;\n  readonly target: string;\n  readonly targetFamily: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n  readonly capabilities?: Record<string, Record<string, boolean>>;\n  readonly extensionPacks?: Record<string, unknown>;\n  readonly meta?: Record<string, unknown>;\n  readonly sources?: Record<string, Source>;\n}\n\nexport interface FieldType {\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly items?: FieldType;\n  readonly properties?: Record<string, FieldType>;\n}\n\nexport interface Source {\n  readonly readOnly: boolean;\n  readonly projection: Record<string, FieldType>;\n  readonly origin?: Record<string, unknown>;\n  readonly capabilities?: Record<string, boolean>;\n}\n\n// Document family types\nexport interface DocIndex {\n  readonly name: string;\n  readonly keys: Record<string, 'asc' | 'desc'>;\n  readonly unique?: boolean;\n  readonly where?: Expr;\n}\n\nexport type Expr =\n  | { readonly kind: 'eq'; readonly path: ReadonlyArray<string>; readonly value: unknown }\n  | { readonly kind: 'exists'; readonly path: ReadonlyArray<string> };\n\nexport interface DocCollection {\n  readonly name: string;\n  readonly id?: {\n    readonly strategy: 'auto' | 'client' | 'uuid' | 'cuid' | 'objectId';\n  };\n  readonly fields: Record<string, FieldType>;\n  readonly indexes?: ReadonlyArray<DocIndex>;\n  readonly readOnly?: boolean;\n}\n\nexport interface DocumentStorage {\n  readonly document: {\n    readonly collections: Record<string, DocCollection>;\n  };\n}\n\nexport interface DocumentContract extends ContractBase {\n  // Accept string to work with JSON imports; runtime validation ensures 'document'\n  readonly targetFamily: string;\n  readonly storage: DocumentStorage;\n}\n\n// Plan types - target-family agnostic execution types\nexport interface ParamDescriptor {\n  readonly index?: number;\n  readonly name?: string;\n  readonly codecId?: string;\n  readonly nativeType?: string;\n  readonly nullable?: boolean;\n  readonly source: 'dsl' | 'raw';\n  readonly refs?: { table: string; column: string };\n}\n\nexport interface PlanRefs {\n  readonly tables?: readonly string[];\n  readonly columns?: ReadonlyArray<{ table: string; column: string }>;\n  readonly indexes?: ReadonlyArray<{\n    readonly table: string;\n    readonly columns: ReadonlyArray<string>;\n    readonly name?: string;\n  }>;\n}\n\nexport interface PlanMeta {\n  readonly target: string;\n  readonly targetFamily?: string;\n  readonly coreHash: string;\n  readonly profileHash?: string;\n  readonly lane: string;\n  readonly annotations?: {\n    codecs?: Record<string, string>; // alias/param → codec id ('ns/name@v')\n    [key: string]: unknown;\n  };\n  readonly paramDescriptors: ReadonlyArray<ParamDescriptor>;\n  readonly refs?: PlanRefs;\n  readonly projection?: Record<string, string> | ReadonlyArray<string>;\n  /**\n   * Optional mapping of projection alias → column type ID (fully qualified ns/name@version).\n   * Used for codec resolution when AST+refs don't provide enough type info.\n   */\n  readonly projectionTypes?: Record<string, string>;\n}\n\n/**\n * Canonical execution plan shape used by runtimes.\n *\n * - Row is the inferred result row type (TypeScript-only).\n * - Ast is the optional, family-specific AST type (e.g. SQL QueryAst).\n *\n * The payload executed by the runtime is represented by the sql + params pair\n * for now; future families can specialize this via Ast or additional metadata.\n */\nexport interface ExecutionPlan<Row = unknown, Ast = unknown> {\n  readonly sql: string;\n  readonly params: readonly unknown[];\n  readonly ast?: Ast;\n  readonly meta: PlanMeta;\n  /**\n   * Phantom property to carry the Row generic for type-level utilities.\n   * Not set at runtime; used only for ResultType extraction.\n   */\n  readonly _row?: Row;\n}\n\n/**\n * Utility type to extract the Row type from an ExecutionPlan.\n * Example: `type Row = ResultType<typeof plan>`\n *\n * Works with both ExecutionPlan and SqlQueryPlan (SQL query plans before lowering).\n * SqlQueryPlan includes a phantom `_Row` property to preserve the generic parameter\n * for type extraction.\n */\nexport type ResultType<P> = P extends ExecutionPlan<infer R, unknown>\n  ? R\n  : P extends { readonly _Row?: infer R }\n    ? R\n    : never;\n\n/**\n * Type guard to check if a contract is a Document contract\n */\nexport function isDocumentContract(contract: unknown): contract is DocumentContract {\n  return (\n    typeof contract === 'object' &&\n    contract !== null &&\n    'targetFamily' in contract &&\n    contract.targetFamily === 'document'\n  );\n}\n\n/**\n * Contract marker record stored in the database.\n * Represents the current contract identity for a database.\n */\nexport interface ContractMarkerRecord {\n  readonly coreHash: string;\n  readonly profileHash: string;\n  readonly contractJson: unknown | null;\n  readonly canonicalVersion: number | null;\n  readonly updatedAt: Date;\n  readonly appTag: string | null;\n  readonly meta: Record<string, unknown>;\n}\n\n// Emitter types - moved from @prisma-next/emitter to shared location\n/**\n * Specifies how to import TypeScript types from a package.\n * Used in extension pack manifests to declare codec and operation type imports.\n */\nexport interface TypesImportSpec {\n  readonly package: string;\n  readonly named: string;\n  readonly alias: string;\n}\n\n/**\n * Validation context passed to TargetFamilyHook.validateTypes().\n * Contains pre-assembled operation registry, type imports, and extension IDs.\n */\nexport interface ValidationContext {\n  readonly operationRegistry?: OperationRegistry;\n  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;\n  readonly extensionIds?: ReadonlyArray<string>;\n}\n\n/**\n * SPI interface for target family hooks that extend emission behavior.\n * Implemented by family-specific emitter hooks (e.g., SQL family).\n */\nexport interface TargetFamilyHook {\n  readonly id: string;\n\n  /**\n   * Validates that all type IDs in the contract come from referenced extension packs.\n   * @param ir - Contract IR to validate\n   * @param ctx - Validation context with operation registry and extension IDs\n   */\n  validateTypes(ir: ContractIR, ctx: ValidationContext): void;\n\n  /**\n   * Validates family-specific contract structure.\n   * @param ir - Contract IR to validate\n   */\n  validateStructure(ir: ContractIR): void;\n\n  /**\n   * Generates contract.d.ts file content.\n   * @param ir - Contract IR\n   * @param codecTypeImports - Array of codec type import specs\n   * @param operationTypeImports - Array of operation type import specs\n   * @returns Generated TypeScript type definitions as string\n   */\n  generateContractTypes(\n    ir: ContractIR,\n    codecTypeImports: ReadonlyArray<TypesImportSpec>,\n    operationTypeImports: ReadonlyArray<TypesImportSpec>,\n  ): string;\n}\n\n// Extension pack manifest types - moved from @prisma-next/core-control-plane to shared location\nexport type ArgSpecManifest =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'param' }\n  | { readonly kind: 'literal' };\n\nexport type ReturnSpecManifest =\n  | { readonly kind: 'typeId'; readonly type: string }\n  | { readonly kind: 'builtin'; readonly type: 'number' | 'boolean' | 'string' };\n\nexport interface LoweringSpecManifest {\n  readonly targetFamily: 'sql';\n  readonly strategy: 'infix' | 'function';\n  readonly template: string;\n}\n\nexport interface OperationManifest {\n  readonly for: string;\n  readonly method: string;\n  readonly args: ReadonlyArray<ArgSpecManifest>;\n  readonly returns: ReturnSpecManifest;\n  readonly lowering: LoweringSpecManifest;\n  readonly capabilities?: ReadonlyArray<string>;\n}\n"],"mappings":";AA8IO,SAAS,mBAAmB,UAAiD;AAClF,SACE,OAAO,aAAa,YACpB,aAAa,QACb,kBAAkB,YAClB,SAAS,iBAAiB;AAE9B;","names":[]}

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.1.0-dev.3",
+  "version": "0.1.0-dev.30",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/operations": "0.1.0-dev.3"
+    "@prisma-next/operations": "0.1.0-dev.30"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^2.1.1",
+    "@vitest/coverage-v8": "^4.0.0",
     "tsup": "^8.3.0",
     "typescript": "^5.9.3",
-    "vitest": "^2.1.1",
+    "vitest": "^4.0.16",
     "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
@@ -31,6 +31,10 @@
       "types": "./dist/exports/ir.d.ts",
       "import": "./dist/exports/ir.js"
     },
+    "./framework-components": {
+      "types": "./dist/exports/framework-components.d.ts",
+      "import": "./dist/exports/framework-components.js"
+    },
     "./schema-document": "./schemas/data-contract-document-v1.json"
   },
   "scripts": {
@@ -38,7 +42,9 @@
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
-    "clean": "node ../../scripts/clean.mjs"
+    "lint": "biome check . --config-path ../../../../../biome.json --error-on-warnings",
+    "lint:fix": "biome check --write . --config-path ../../../biome.json",
+    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
+    "clean": "node ../../../../../scripts/clean.mjs"
   }
 }