@prisma-next/extension-arktype-json 0.0.1

package/README.md

@@ -0,0 +1,91 @@
+# `@prisma-next/extension-arktype-json`
+
+Per-library JSON-with-schema column factory for Prisma Next, built on
+[arktype](https://arktype.io). Ships the `arktypeJson(schema)` column-author
+helper and the `arktype/json@1` codec descriptor.
+
+## What it does
+
+Given an arktype `Type`, `arktypeJson(schema)` produces a column descriptor
+that:
+
+- Stores values as `jsonb` on Postgres.
+- Eagerly serializes `schema.expression` (TypeScript-source-like rendering)
+  and `schema.json` (arktype's internal IR) into `typeParams`. The IR is the
+  lossless rehydration source; the expression is the emit-path renderer's
+  input.
+- At runtime, the framework's unified codec descriptor map rehydrates the
+  schema via `ark.schema(typeParams.jsonIr)` and returns a `Codec` whose
+  `decode` validates wire payloads via the rehydrated schema. Validation
+  failures throw `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED`.
+- The emitter renders the column's TS type as the schema's `expression`
+  (e.g. `{ name: string; price: number }`).
+
+## Why a per-library extension
+
+The unified `CodecDescriptor` model routes JSON-with-schema through per-
+library extension packages: arktype-json now, future zod / valibot
+extensions when each has a clean serialize / rehydrate story. The Postgres
+adapter retains only the storage-level `jsonColumn` / `jsonbColumn`
+descriptors (untyped raw JSON). See [ADR 208 — Higher-order codecs for parameterized types](../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md).
+
+## Usage
+
+```ts
+import { type } from 'arktype';
+import { arktypeJson } from '@prisma-next/extension-arktype-json/column-types';
+import { defineContract, field, model } from '@prisma-next/sql-contract-ts/contract-builder';
+
+const ProductSchema = type({ name: 'string', price: 'number', 'description?': 'string' });
+
+const contract = defineContract({ /* ... */ }, ({ field, model }) => ({
+  models: {
+    Product: model('Product', {
+      fields: {
+        id: field.id.uuidv4(),
+        spec: field.column(arktypeJson(ProductSchema)),
+        //                  ^? Type<{ name: string; price: number; description?: string }>
+      },
+    }).sql({ table: 'product' }),
+  },
+}));
+```
+
+In the emitted `contract.d.ts`, `Product.spec` resolves to
+`{ name: string; price: number; description?: string }` — the schema's
+expression renders directly into the field type.
+
+## Pack registration
+
+Add the runtime descriptor to your runtime stack and the control descriptor
+to your `prisma-next.config.ts` `extensionPacks`:
+
+```ts
+import arktypeJsonPack from '@prisma-next/extension-arktype-json/pack';
+import arktypeJsonRuntime from '@prisma-next/extension-arktype-json/runtime';
+
+// prisma-next.config.ts
+export default {
+  extensionPacks: { arktypeJson: arktypeJsonPack },
+  // ...
+};
+
+// runtime
+const stack = createSqlExecutionStack({
+  target: postgresTarget,
+  adapter: postgresAdapter,
+  extensionPacks: [arktypeJsonRuntime],
+});
+```
+
+## Notes
+
+- The codec is library-bound (`arktype/json@1`), not target-bound. Other
+  schema libraries ship as parallel extensions (`zod/json@1`,
+  `valibot/json@1`) when their serialize/rehydrate stories materialize.
+- `decode` validates internally and throws on rejection; the framework's
+  `JsonSchemaValidatorRegistry` is not consulted for arktype-json columns
+  (no `'json-validator'` trait + per-instance `validate` extraction). The
+  one-path "validate inside `decode`" matches the spec's Case J pinning.
+- For untyped raw JSON columns, use `jsonColumn` / `jsonbColumn` from
+  `@prisma-next/adapter-postgres/column-types` instead.

package/dist/arktype-json-codec-BbiBmtTK.mjs

@@ -0,0 +1,224 @@
+import { runtimeError } from "@prisma-next/framework-components/runtime";
+import { codec } from "@prisma-next/sql-relational-core/ast";
+import { ArkErrors, ark, type } from "arktype";
+
+//#region src/core/arktype-json-codec.ts
+/** Codec id for arktype-backed JSON columns. Library-bound, not target-bound. */
+const ARKTYPE_JSON_CODEC_ID = "arktype/json@1";
+/** Native storage type backing the codec. JSONB on Postgres; binary, indexable. */
+const ARKTYPE_JSON_NATIVE_TYPE = "jsonb";
+/**
+* Type predicate for `ArktypeSchemaLike`. Lets the column-author
+* factory narrow `unknown` schemas to the structural shape the codec
+* depends on after the explicit field guards run, so the descriptor
+* builder doesn't fall back to a `as unknown as` cast.
+*/
+function isArktypeSchemaLike(value) {
+	if (typeof value !== "function") return false;
+	return typeof value.expression === "string";
+}
+/**
+* Build the curried factory for a rehydrated arktype schema. The factory's
+* returned codec carries the schema in its closure; `decode` validates
+* wire payloads via `schema(parsed)`, throwing
+* `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on rejection.
+*
+* Encode is `JSON.stringify` — the schema validates the input shape only
+* at the read boundary (decode), matching the JSON-validator philosophy:
+* the payload may have been written by any source (this writer, a
+* previous version of the schema, a manual SQL `INSERT`); validate when
+* reading, not when writing.
+*
+* Author bodies are sync; main's `codec({...})` factory promise-lifts
+* `encode`/`decode` into the framework-required `Promise<…>` boundary
+* shape (per ADR 204).
+*/
+function arktypeJsonCodecForSchema(schema) {
+	function validateSchema(value) {
+		const result = schema(value);
+		if (result instanceof ArkErrors) throw runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `arktype-json schema validation failed (decode): ${result.summary}`, {
+			codecId: ARKTYPE_JSON_CODEC_ID,
+			issues: result.summary
+		});
+		return result;
+	}
+	function serializeToJsonSafe(value) {
+		const wire = JSON.stringify(value);
+		if (typeof wire !== "string") throw runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `arktype-json value is not representable as JSON (codecId: ${ARKTYPE_JSON_CODEC_ID})`, { codecId: ARKTYPE_JSON_CODEC_ID });
+		const json = JSON.parse(wire);
+		validateSchema(json);
+		return {
+			wire,
+			json
+		};
+	}
+	return (_ctx) => codec({
+		typeId: ARKTYPE_JSON_CODEC_ID,
+		targetTypes: [ARKTYPE_JSON_NATIVE_TYPE],
+		traits: ["equality"],
+		encode: (value) => serializeToJsonSafe(value).wire,
+		decode: (wire) => validateSchema(JSON.parse(wire)),
+		encodeJson: (value) => serializeToJsonSafe(value).json,
+		decodeJson: (json) => validateSchema(json)
+	});
+}
+/**
+* Curried column-author factory for arktype-validated JSON columns.
+*
+* Usage:
+*
+* ```ts
+* import { type } from 'arktype';
+* import { arktypeJson } from '@prisma-next/extension-arktype-json/column-types';
+*
+* const ProductSchema = type({ name: 'string', price: 'number' });
+*
+* const Product = {
+*   columns: {
+*     id: textCodec,
+*     settings: arktypeJson(ProductSchema),
+*     //        ^? ColumnTypeDescriptor with type :: (ctx) => Codec<…, { name: string; price: number }>
+*   },
+* };
+* ```
+*
+* The schema's inferred output flows through `S['infer']` so the no-emit
+* `FieldOutputType` resolver produces the precise TS type at the column
+* site. Eager serialization at this call site captures `expression` (for
+* the emit-path renderer) and `jsonIr` (for runtime rehydration).
+*
+* @throws {Error} if the schema doesn't expose `expression` and `json`
+*   fields (i.e. is not an arktype `Type`). The factory validates the
+*   schema shape at the call site so configuration errors surface during
+*   contract authoring, not at runtime.
+*/
+function arktypeJson(schema) {
+	if (!isArktypeSchemaLike(schema)) throw new Error(typeof schema !== "function" ? "arktypeJson(schema) expects a callable arktype Type." : "arktypeJson(schema) expects an arktype Type (missing `expression: string`).");
+	const jsonIr = schema.json;
+	if (jsonIr === null || typeof jsonIr !== "object") throw new Error("arktypeJson(schema) expects an arktype Type (missing `json` IR).");
+	return {
+		codecId: ARKTYPE_JSON_CODEC_ID,
+		nativeType: ARKTYPE_JSON_NATIVE_TYPE,
+		typeParams: {
+			expression: schema.expression,
+			jsonIr
+		},
+		type: arktypeJsonCodecForSchema(schema)
+	};
+}
+/**
+* Standard Schema validator for the descriptor's typeParams. Asserts the
+* shape `{ expression: string; jsonIr: object }` at the contract IR
+* boundary; deeper IR-shape validation happens implicitly when
+* `ark.schema(jsonIr)` reparses (corrupt IR throws there).
+*
+* Eats its own dog food: the validator is itself an arktype schema.
+*/
+const arktypeJsonParamsSchema = type({
+	expression: "string",
+	jsonIr: "object"
+});
+/**
+* Rehydrate an arktype schema from the serialized IR. Throws a clean
+* error if the IR is corrupt — the "corruption-of-contract.json" case.
+*/
+function rehydrateSchema(jsonIr) {
+	try {
+		return ark.schema(jsonIr);
+	} catch (error) {
+		throw runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `Failed to rehydrate arktype schema from contract IR: ${error instanceof Error ? error.message : String(error)}`, {
+			codecId: ARKTYPE_JSON_CODEC_ID,
+			jsonIr
+		});
+	}
+}
+/**
+* Render the emit-path TS type for an arktype-json column. Reads the
+* eagerly-extracted `expression` directly — the round-trip stability
+* guarantee (rehydrated schema's `expression` matches the source's)
+* means the rendered output is consistent across serialize/rehydrate.
+*/
+function renderArktypeJsonOutputType(params) {
+	const expression = params.expression.trim();
+	return expression.length > 0 ? expression : "unknown";
+}
+/**
+* Build a permissive `renderOutputType` that accepts the framework's
+* generic typeParams shape and dispatches to the type-narrow renderer
+* once the input is structurally an `ArktypeJsonTypeParams`.
+*/
+function renderArktypeJsonOutputTypeFromUnknownParams(typeParams) {
+	const expression = typeParams["expression"];
+	const jsonIr = typeParams["jsonIr"];
+	if (typeof expression !== "string" || jsonIr === null || typeof jsonIr !== "object") return;
+	return renderArktypeJsonOutputType({
+		expression,
+		jsonIr
+	});
+}
+/**
+* Emit-only `Codec` instance for `arktype/json@1`. Threaded through the
+* pack-meta's `codecInstances` array so the emitter's `CodecLookup` can
+* find a `renderOutputType` for the codec id (the emitter consults the
+* codec-id-keyed `CodecLookup` at the framework boundary; the unified
+* descriptor's `renderOutputType` is the long-term home for the renderer
+* but the emit-path glue still routes through `CodecLookup`).
+*
+* All conversion methods are sentinels that throw if invoked — runtime
+* materialization always goes through `arktypeJsonCodec.factory`'s
+* curried `(params) => (ctx) => Codec`, never through this instance.
+* `encodeJson`/`decodeJson` throw alongside `encode`/`decode` so a
+* mistaken contract-load that resolved to this stub fails fast at the
+* JSON boundary instead of silently returning unvalidated payloads. A
+* future cleanup could route the emit path through the descriptor map
+* directly and retire this shim.
+*/
+const ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR = "arktype-json codec instances must be materialized via the descriptor factory; this is an emit-only stub";
+const arktypeJsonEmitCodec = {
+	id: ARKTYPE_JSON_CODEC_ID,
+	targetTypes: [ARKTYPE_JSON_NATIVE_TYPE],
+	traits: ["equality"],
+	encode: () => Promise.reject(new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR)),
+	decode: () => Promise.reject(new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR)),
+	encodeJson: () => {
+		throw new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR);
+	},
+	decodeJson: () => {
+		throw new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR);
+	},
+	renderOutputType: renderArktypeJsonOutputTypeFromUnknownParams
+};
+/**
+* Framework-registration descriptor for the arktype-json codec. Registered
+* through the SQL runtime's `parameterizedCodecs:` slot. `sql-runtime`'s
+* `initializeTypeHelpers` (and per-column walk in
+* `buildContractCodecRegistry`) calls `arktypeJsonCodec.factory(typeParams)
+* (ctx)` once per `storage.types` instance (or once per inline-typeParams
+* column) to materialize the resolved codec carrying the rehydrated
+* schema.
+*
+* Per Phase B of codec-registry-unification, `descriptorFor('arktype/json@1')`
+* returns this descriptor and its `traits`/`targetTypes` are the codec-id-
+* keyed source of truth — no parallel placeholder on the legacy `codecs:`
+* slot is needed (the runtime descriptor ships `codecs: () => createCodecRegistry()`
+* — empty).
+*/
+const arktypeJsonCodec = {
+	codecId: ARKTYPE_JSON_CODEC_ID,
+	traits: ["equality"],
+	targetTypes: [ARKTYPE_JSON_NATIVE_TYPE],
+	paramsSchema: arktypeJsonParamsSchema,
+	renderOutputType: renderArktypeJsonOutputType,
+	factory: (params) => {
+		const schema = rehydrateSchema(params.jsonIr);
+		/* c8 ignore start — defensive parity check; not exercised by typical contracts */
+		const rehydratedExpression = schema.expression;
+		if (typeof rehydratedExpression === "string" && rehydratedExpression !== params.expression) console.warn(`[arktype-json] typeParams.expression (${params.expression}) does not match rehydrated schema expression (${rehydratedExpression}); contract.json may be stale relative to the runtime schema.`);
+		/* c8 ignore stop */
+		return arktypeJsonCodecForSchema(schema);
+	}
+};
+
+//#endregion
+export { arktypeJsonEmitCodec as a, arktypeJsonCodec as i, ARKTYPE_JSON_NATIVE_TYPE as n, arktypeJson as r, ARKTYPE_JSON_CODEC_ID as t };
+//# sourceMappingURL=arktype-json-codec-BbiBmtTK.mjs.map

package/dist/arktype-json-codec-BbiBmtTK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-BbiBmtTK.mjs","names":["wire: string | undefined","jsonIr: unknown","arktypeJsonEmitCodec: Codec<\n  typeof ARKTYPE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string,\n  unknown\n>","arktypeJsonCodec: CodecDescriptor<ArktypeJsonTypeParams>"],"sources":["../src/core/arktype-json-codec.ts"],"sourcesContent":["/**\n * Single source of truth for the arktype-json `arktype/json@1` codec.\n *\n * Ships the per-library JSON-with-schema column factory (`arktypeJson`) and\n * the framework-registration descriptor (`arktypeJsonCodec`). The two\n * surfaces share one serialize/rehydrate pipeline keyed on arktype's\n * internal IR.\n *\n * **Serialization** (column-author site, eager):\n *\n * - `expression`: `schema.expression` — arktype's TypeScript-source-like\n *   rendering used by the emit-path `renderOutputType` to produce the\n *   column's TS type in `contract.d.ts`.\n * - `jsonIr`: `schema.json` — arktype's internal IR. Lossless; the\n *   rehydration source consumed by `ark.schema(jsonIr)` at runtime.\n *\n * The pair is sufficient: `expression` round-trips with the rehydrated\n * schema (`ark.schema(jsonIr).expression === expression`) so the emit-path\n * output is stable across serialize/rehydrate.\n *\n * **Rehydration** (runtime, on factory invocation): `ark.schema(typeParams.jsonIr)`\n * returns a callable `Type`-like with `~standard`. The returned codec's\n * `decode` body validates wire payloads through the rehydrated schema and\n * throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on rejection — no separate\n * validator-registry consultation.\n *\n * See the codec-registry-unification spec § Case J (JSON-with-schema).\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type {\n  Codec,\n  CodecDescriptor,\n  CodecInstanceContext,\n} from '@prisma-next/framework-components/codec';\nimport { runtimeError } from '@prisma-next/framework-components/runtime';\nimport { codec } from '@prisma-next/sql-relational-core/ast';\nimport { ArkErrors, ark, type Type, type } from 'arktype';\n\n// ── Constants ────────────────────────────────────────────────────────────\n\n/** Codec id for arktype-backed JSON columns. Library-bound, not target-bound. */\nexport const ARKTYPE_JSON_CODEC_ID = 'arktype/json@1' as const;\n\n/** Native storage type backing the codec. JSONB on Postgres; binary, indexable. */\nexport const ARKTYPE_JSON_NATIVE_TYPE = 'jsonb' as const;\n\n// ── typeParams shape ─────────────────────────────────────────────────────\n\n/**\n * Eagerly serialized typeParams for the arktype-json column. Carried in\n * the contract IR; the runtime descriptor's factory rehydrates `jsonIr`\n * and the emitter consumes `expression`.\n */\nexport type ArktypeJsonTypeParams = {\n  /**\n   * Arktype's TypeScript-source-like rendering of the schema. Read by\n   * `renderOutputType` to emit the column's TS type into `contract.d.ts`.\n   * Stable across the serialize/rehydrate cycle: the rehydrated schema's\n   * `expression` matches the source schema's.\n   */\n  readonly expression: string;\n  /**\n   * Arktype's internal IR for the schema. Lossless; the rehydration\n   * source. Schema-shape — `ark.schema(jsonIr)` reconstructs a callable\n   * `Type`-like structurally identical to the original `type(definition)`\n   * output.\n   */\n  readonly jsonIr: object;\n};\n\n// ── Curried higher-order codec factory ───────────────────────────────────\n\n/**\n * Codec instance returned by `arktypeJson(schema)(ctx)` and by\n * `arktypeJsonCodec.factory(typeParams)(ctx)`. The `TInferred` slot\n * carries the arktype schema's inferred output type.\n */\nexport type ArktypeJsonCodec<TInferred> = Codec<\n  typeof ARKTYPE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string,\n  TInferred\n>;\n\n/**\n * Structural narrow of arktype's `Type` — the surface our codec depends\n * on: a callable validator that returns `inferOut | ArkErrors`, plus the\n * `expression` string for emit-path rendering.\n *\n * Avoids depending on the precise generics of arktype's `Type<t, $>` so\n * schemas built in any scope (the default `Ark` from `type(...)` AND the\n * minimal scope from `ark.schema(...)`) satisfy the same contract.\n */\ntype ArktypeSchemaLike = ((value: unknown) => unknown) & {\n  readonly expression: string;\n};\n\n/**\n * Type predicate for `ArktypeSchemaLike`. Lets the column-author\n * factory narrow `unknown` schemas to the structural shape the codec\n * depends on after the explicit field guards run, so the descriptor\n * builder doesn't fall back to a `as unknown as` cast.\n */\nfunction isArktypeSchemaLike(value: unknown): value is ArktypeSchemaLike {\n  if (typeof value !== 'function') return false;\n  const expression = (value as { readonly expression?: unknown }).expression;\n  return typeof expression === 'string';\n}\n\n/**\n * Build the curried factory for a rehydrated arktype schema. The factory's\n * returned codec carries the schema in its closure; `decode` validates\n * wire payloads via `schema(parsed)`, throwing\n * `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on rejection.\n *\n * Encode is `JSON.stringify` — the schema validates the input shape only\n * at the read boundary (decode), matching the JSON-validator philosophy:\n * the payload may have been written by any source (this writer, a\n * previous version of the schema, a manual SQL `INSERT`); validate when\n * reading, not when writing.\n *\n * Author bodies are sync; main's `codec({...})` factory promise-lifts\n * `encode`/`decode` into the framework-required `Promise<…>` boundary\n * shape (per ADR 204).\n */\nfunction arktypeJsonCodecForSchema<TInferred>(\n  schema: ArktypeSchemaLike,\n): (ctx: CodecInstanceContext) => ArktypeJsonCodec<TInferred> {\n  // Shared schema check used by both `decode` (wire → JS) and\n  // `decodeJson` (JsonValue → JS). Either entry point must reject\n  // payloads that don't match the schema; without the shared validator,\n  // any caller that hands parsed JSON straight to the codec would bypass\n  // schema enforcement and return unchecked data.\n  function validateSchema(value: unknown): TInferred {\n    const result = schema(value);\n    if (result instanceof ArkErrors) {\n      throw runtimeError(\n        'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',\n        `arktype-json schema validation failed (decode): ${result.summary}`,\n        { codecId: ARKTYPE_JSON_CODEC_ID, issues: result.summary },\n      );\n    }\n    // arktype's call-result is `inferOut | ArkErrors`; the ArkErrors\n    // branch is excluded above. The cast threads the caller-supplied\n    // generic onto the structurally-typed validation output.\n    return result as TInferred;\n  }\n\n  // Derive both `encode` (wire string) and `encodeJson` (JsonValue)\n  // outputs from the same `JSON.stringify` → `JSON.parse` round-trip,\n  // then validate the normalized payload through the schema. Without\n  // this normalization, a non-JSON-safe runtime value (e.g. a class\n  // instance, a function field on a narrowed type) could slip through\n  // `encodeJson` unchanged while `encode` silently dropped or\n  // transformed it — producing wire payloads the codec's own decode\n  // path would later reject. The serialize/parse round-trip also\n  // produces the JSON-safe shape required by the contract IR's\n  // `JsonValue` surface, so `encodeJson` no longer needs a blind cast.\n  function serializeToJsonSafe(value: TInferred): { wire: string; json: JsonValue } {\n    // `JSON.stringify` returns `string | undefined` — `undefined`\n    // happens when the input is `undefined` itself or contains only\n    // unserializable values (functions, symbols). Reject explicitly so\n    // the caller sees the schema-failure code rather than a downstream\n    // `JSON.parse(undefined)` SyntaxError.\n    const wire: string | undefined = JSON.stringify(value);\n    if (typeof wire !== 'string') {\n      throw runtimeError(\n        'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',\n        `arktype-json value is not representable as JSON (codecId: ${ARKTYPE_JSON_CODEC_ID})`,\n        { codecId: ARKTYPE_JSON_CODEC_ID },\n      );\n    }\n    const json = JSON.parse(wire) as JsonValue;\n    // Validate the normalized payload — the round-trip strips\n    // class-prototype shape and arktype-narrowed fields, and the\n    // schema must still accept the result. Run validation and discard\n    // its return value (we keep `json` as the JsonValue, not the\n    // schema's `inferOut` which already matches `TInferred`).\n    validateSchema(json);\n    return { wire, json };\n  }\n\n  return (_ctx) =>\n    codec<typeof ARKTYPE_JSON_CODEC_ID, readonly ['equality'], string, TInferred>({\n      typeId: ARKTYPE_JSON_CODEC_ID,\n      targetTypes: [ARKTYPE_JSON_NATIVE_TYPE],\n      traits: ['equality'] as const,\n      encode: (value: TInferred): string => serializeToJsonSafe(value).wire,\n      decode: (wire: string): TInferred => validateSchema(JSON.parse(wire)),\n      encodeJson: (value: TInferred): JsonValue => serializeToJsonSafe(value).json,\n      decodeJson: (json: JsonValue) => validateSchema(json),\n    }) as ArktypeJsonCodec<TInferred>;\n}\n\n// ── Column-author surface ────────────────────────────────────────────────\n\n/**\n * Curried column-author factory for arktype-validated JSON columns.\n *\n * Usage:\n *\n * ```ts\n * import { type } from 'arktype';\n * import { arktypeJson } from '@prisma-next/extension-arktype-json/column-types';\n *\n * const ProductSchema = type({ name: 'string', price: 'number' });\n *\n * const Product = {\n *   columns: {\n *     id: textCodec,\n *     settings: arktypeJson(ProductSchema),\n *     //        ^? ColumnTypeDescriptor with type :: (ctx) => Codec<…, { name: string; price: number }>\n *   },\n * };\n * ```\n *\n * The schema's inferred output flows through `S['infer']` so the no-emit\n * `FieldOutputType` resolver produces the precise TS type at the column\n * site. Eager serialization at this call site captures `expression` (for\n * the emit-path renderer) and `jsonIr` (for runtime rehydration).\n *\n * @throws {Error} if the schema doesn't expose `expression` and `json`\n *   fields (i.e. is not an arktype `Type`). The factory validates the\n *   schema shape at the call site so configuration errors surface during\n *   contract authoring, not at runtime.\n */\nexport function arktypeJson<S extends Type<unknown>>(\n  schema: S,\n): ColumnTypeDescriptor & {\n  readonly codecId: typeof ARKTYPE_JSON_CODEC_ID;\n  readonly nativeType: typeof ARKTYPE_JSON_NATIVE_TYPE;\n  readonly typeParams: ArktypeJsonTypeParams;\n  readonly type: (ctx: CodecInstanceContext) => ArktypeJsonCodec<S['infer']>;\n} {\n  // Reject non-callable / non-arktype-shaped lookalikes before any\n  // property reads. An object shaped like `{ expression, json }` would\n  // otherwise pass the field checks and only explode on the first\n  // `decode`/`decodeJson` call, defeating the early authoring-time\n  // guard this factory provides. The `isArktypeSchemaLike` predicate\n  // narrows `schema` so the descriptor builder hands the typed shape\n  // straight to the curried factory — no `as unknown as` cast.\n  if (!isArktypeSchemaLike(schema)) {\n    throw new Error(\n      typeof schema !== 'function'\n        ? 'arktypeJson(schema) expects a callable arktype Type.'\n        : 'arktypeJson(schema) expects an arktype Type (missing `expression: string`).',\n    );\n  }\n  const jsonIr: unknown = (schema as { readonly json?: unknown }).json;\n  if (jsonIr === null || typeof jsonIr !== 'object') {\n    throw new Error('arktypeJson(schema) expects an arktype Type (missing `json` IR).');\n  }\n  return {\n    codecId: ARKTYPE_JSON_CODEC_ID,\n    nativeType: ARKTYPE_JSON_NATIVE_TYPE,\n    typeParams: { expression: schema.expression, jsonIr },\n    type: arktypeJsonCodecForSchema<S['infer']>(schema),\n  } as const;\n}\n\n// ── Framework-registration descriptor ────────────────────────────────────\n\n/**\n * Standard Schema validator for the descriptor's typeParams. Asserts the\n * shape `{ expression: string; jsonIr: object }` at the contract IR\n * boundary; deeper IR-shape validation happens implicitly when\n * `ark.schema(jsonIr)` reparses (corrupt IR throws there).\n *\n * Eats its own dog food: the validator is itself an arktype schema.\n */\nconst arktypeJsonParamsSchema = type({\n  expression: 'string',\n  jsonIr: 'object',\n});\n\n/**\n * Rehydrate an arktype schema from the serialized IR. Throws a clean\n * error if the IR is corrupt — the \"corruption-of-contract.json\" case.\n */\nfunction rehydrateSchema(jsonIr: object): ArktypeSchemaLike {\n  try {\n    return ark.schema(jsonIr) as unknown as ArktypeSchemaLike;\n  } catch (error) {\n    throw runtimeError(\n      'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',\n      `Failed to rehydrate arktype schema from contract IR: ${error instanceof Error ? error.message : String(error)}`,\n      { codecId: ARKTYPE_JSON_CODEC_ID, jsonIr },\n    );\n  }\n}\n\n/**\n * Render the emit-path TS type for an arktype-json column. Reads the\n * eagerly-extracted `expression` directly — the round-trip stability\n * guarantee (rehydrated schema's `expression` matches the source's)\n * means the rendered output is consistent across serialize/rehydrate.\n */\nfunction renderArktypeJsonOutputType(params: ArktypeJsonTypeParams): string {\n  const expression = params.expression.trim();\n  return expression.length > 0 ? expression : 'unknown';\n}\n\n/**\n * Build a permissive `renderOutputType` that accepts the framework's\n * generic typeParams shape and dispatches to the type-narrow renderer\n * once the input is structurally an `ArktypeJsonTypeParams`.\n */\nfunction renderArktypeJsonOutputTypeFromUnknownParams(\n  typeParams: Record<string, unknown>,\n): string | undefined {\n  const expression = typeParams['expression'];\n  const jsonIr = typeParams['jsonIr'];\n  if (typeof expression !== 'string' || jsonIr === null || typeof jsonIr !== 'object') {\n    return undefined;\n  }\n  return renderArktypeJsonOutputType({ expression, jsonIr });\n}\n\n/**\n * Emit-only `Codec` instance for `arktype/json@1`. Threaded through the\n * pack-meta's `codecInstances` array so the emitter's `CodecLookup` can\n * find a `renderOutputType` for the codec id (the emitter consults the\n * codec-id-keyed `CodecLookup` at the framework boundary; the unified\n * descriptor's `renderOutputType` is the long-term home for the renderer\n * but the emit-path glue still routes through `CodecLookup`).\n *\n * All conversion methods are sentinels that throw if invoked — runtime\n * materialization always goes through `arktypeJsonCodec.factory`'s\n * curried `(params) => (ctx) => Codec`, never through this instance.\n * `encodeJson`/`decodeJson` throw alongside `encode`/`decode` so a\n * mistaken contract-load that resolved to this stub fails fast at the\n * JSON boundary instead of silently returning unvalidated payloads. A\n * future cleanup could route the emit path through the descriptor map\n * directly and retire this shim.\n */\nconst ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR =\n  'arktype-json codec instances must be materialized via the descriptor factory; this is an emit-only stub';\n\nexport const arktypeJsonEmitCodec: Codec<\n  typeof ARKTYPE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string,\n  unknown\n> = {\n  id: ARKTYPE_JSON_CODEC_ID,\n  targetTypes: [ARKTYPE_JSON_NATIVE_TYPE],\n  traits: ['equality'] as const,\n  encode: () => Promise.reject(new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR)),\n  decode: () => Promise.reject(new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR)),\n  encodeJson: () => {\n    throw new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR);\n  },\n  decodeJson: () => {\n    throw new Error(ARKTYPE_JSON_RUNTIME_DISPATCH_ERROR);\n  },\n  renderOutputType: renderArktypeJsonOutputTypeFromUnknownParams,\n};\n\n/**\n * Framework-registration descriptor for the arktype-json codec. Registered\n * through the SQL runtime's `parameterizedCodecs:` slot. `sql-runtime`'s\n * `initializeTypeHelpers` (and per-column walk in\n * `buildContractCodecRegistry`) calls `arktypeJsonCodec.factory(typeParams)\n * (ctx)` once per `storage.types` instance (or once per inline-typeParams\n * column) to materialize the resolved codec carrying the rehydrated\n * schema.\n *\n * Per Phase B of codec-registry-unification, `descriptorFor('arktype/json@1')`\n * returns this descriptor and its `traits`/`targetTypes` are the codec-id-\n * keyed source of truth — no parallel placeholder on the legacy `codecs:`\n * slot is needed (the runtime descriptor ships `codecs: () => createCodecRegistry()`\n * — empty).\n */\nexport const arktypeJsonCodec: CodecDescriptor<ArktypeJsonTypeParams> = {\n  codecId: ARKTYPE_JSON_CODEC_ID,\n  traits: ['equality'] as const,\n  targetTypes: [ARKTYPE_JSON_NATIVE_TYPE] as const,\n  paramsSchema: arktypeJsonParamsSchema,\n  renderOutputType: renderArktypeJsonOutputType,\n  factory: (params) => {\n    const schema = rehydrateSchema(params.jsonIr);\n    /* c8 ignore start — defensive parity check; not exercised by typical contracts */\n    // The rehydrated schema's `expression` should match the serialized\n    // one; diverging means contract.json was hand-edited out from under\n    // the emit-path renderer. Surface as a soft warning at materialization\n    // time so the caller knows their emit output may not match the\n    // runtime schema. The runtime keeps using the schema rehydrated from\n    // `jsonIr` — that's the lossless source — so the worst case is an\n    // emit-vs-runtime divergence at a single column, not a runtime\n    // failure.\n    const rehydratedExpression = (schema as { readonly expression?: unknown }).expression;\n    if (typeof rehydratedExpression === 'string' && rehydratedExpression !== params.expression) {\n      console.warn(\n        `[arktype-json] typeParams.expression (${params.expression}) does not match rehydrated schema expression (${rehydratedExpression}); contract.json may be stale relative to the runtime schema.`,\n      );\n    }\n    /* c8 ignore stop */\n    return arktypeJsonCodecForSchema<unknown>(schema);\n  },\n};\n"],"mappings":"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"}

package/dist/arktype-json-codec-yNv1hzBm.d.mts

@@ -0,0 +1,92 @@
+import { Type } from "arktype";
+import { ColumnTypeDescriptor } from "@prisma-next/contract-authoring";
+import { Codec, CodecDescriptor, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+
+//#region src/core/arktype-json-codec.d.ts
+
+/** Codec id for arktype-backed JSON columns. Library-bound, not target-bound. */
+declare const ARKTYPE_JSON_CODEC_ID: "arktype/json@1";
+/** Native storage type backing the codec. JSONB on Postgres; binary, indexable. */
+declare const ARKTYPE_JSON_NATIVE_TYPE: "jsonb";
+/**
+ * Eagerly serialized typeParams for the arktype-json column. Carried in
+ * the contract IR; the runtime descriptor's factory rehydrates `jsonIr`
+ * and the emitter consumes `expression`.
+ */
+type ArktypeJsonTypeParams = {
+  /**
+   * Arktype's TypeScript-source-like rendering of the schema. Read by
+   * `renderOutputType` to emit the column's TS type into `contract.d.ts`.
+   * Stable across the serialize/rehydrate cycle: the rehydrated schema's
+   * `expression` matches the source schema's.
+   */
+  readonly expression: string;
+  /**
+   * Arktype's internal IR for the schema. Lossless; the rehydration
+   * source. Schema-shape — `ark.schema(jsonIr)` reconstructs a callable
+   * `Type`-like structurally identical to the original `type(definition)`
+   * output.
+   */
+  readonly jsonIr: object;
+};
+/**
+ * Codec instance returned by `arktypeJson(schema)(ctx)` and by
+ * `arktypeJsonCodec.factory(typeParams)(ctx)`. The `TInferred` slot
+ * carries the arktype schema's inferred output type.
+ */
+type ArktypeJsonCodec<TInferred> = Codec<typeof ARKTYPE_JSON_CODEC_ID, readonly ['equality'], string, TInferred>;
+/**
+ * Curried column-author factory for arktype-validated JSON columns.
+ *
+ * Usage:
+ *
+ * ```ts
+ * import { type } from 'arktype';
+ * import { arktypeJson } from '@prisma-next/extension-arktype-json/column-types';
+ *
+ * const ProductSchema = type({ name: 'string', price: 'number' });
+ *
+ * const Product = {
+ *   columns: {
+ *     id: textCodec,
+ *     settings: arktypeJson(ProductSchema),
+ *     //        ^? ColumnTypeDescriptor with type :: (ctx) => Codec<…, { name: string; price: number }>
+ *   },
+ * };
+ * ```
+ *
+ * The schema's inferred output flows through `S['infer']` so the no-emit
+ * `FieldOutputType` resolver produces the precise TS type at the column
+ * site. Eager serialization at this call site captures `expression` (for
+ * the emit-path renderer) and `jsonIr` (for runtime rehydration).
+ *
+ * @throws {Error} if the schema doesn't expose `expression` and `json`
+ *   fields (i.e. is not an arktype `Type`). The factory validates the
+ *   schema shape at the call site so configuration errors surface during
+ *   contract authoring, not at runtime.
+ */
+declare function arktypeJson<S extends Type<unknown>>(schema: S): ColumnTypeDescriptor & {
+  readonly codecId: typeof ARKTYPE_JSON_CODEC_ID;
+  readonly nativeType: typeof ARKTYPE_JSON_NATIVE_TYPE;
+  readonly typeParams: ArktypeJsonTypeParams;
+  readonly type: (ctx: CodecInstanceContext) => ArktypeJsonCodec<S['infer']>;
+};
+/**
+ * Framework-registration descriptor for the arktype-json codec. Registered
+ * through the SQL runtime's `parameterizedCodecs:` slot. `sql-runtime`'s
+ * `initializeTypeHelpers` (and per-column walk in
+ * `buildContractCodecRegistry`) calls `arktypeJsonCodec.factory(typeParams)
+ * (ctx)` once per `storage.types` instance (or once per inline-typeParams
+ * column) to materialize the resolved codec carrying the rehydrated
+ * schema.
+ *
+ * Per Phase B of codec-registry-unification, `descriptorFor('arktype/json@1')`
+ * returns this descriptor and its `traits`/`targetTypes` are the codec-id-
+ * keyed source of truth — no parallel placeholder on the legacy `codecs:`
+ * slot is needed (the runtime descriptor ships `codecs: () => createCodecRegistry()`
+ * — empty).
+ */
+declare const arktypeJsonCodec: CodecDescriptor<ArktypeJsonTypeParams>;
+//#endregion
+export { arktypeJson as a, ArktypeJsonTypeParams as i, ARKTYPE_JSON_NATIVE_TYPE as n, arktypeJsonCodec as o, ArktypeJsonCodec as r, ARKTYPE_JSON_CODEC_ID as t };
+//# sourceMappingURL=arktype-json-codec-yNv1hzBm.d.mts.map

package/dist/arktype-json-codec-yNv1hzBm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-yNv1hzBm.d.mts","names":[],"sources":["../src/core/arktype-json-codec.ts"],"sourcesContent":[],"mappings":";;;;;;;cA2Ca;;cAGA;;;;;;KASD,qBAAA;;;;;;;;;;;;;;;;;;;;;KAwBA,8BAA8B,aACjC,sDAGP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiJc,sBAAsB,uBAC5B,IACP;2BACwB;8BACG;uBACP;uBACA,yBAAyB,iBAAiB;;;;;;;;;;;;;;;;;cA6IpD,kBAAkB,gBAAgB"}

package/dist/codec-types-CH37Yc0C.d.mts

@@ -0,0 +1,27 @@
+//#region src/types/codec-types.d.ts
+/**
+ * Codec type definitions for the arktype-json extension.
+ *
+ * Type-only export consumed by emitted `contract.d.ts` to power
+ * `CodecTypes['arktype/json@1']['output']` lookups. The shape mirrors the
+ * codec the curried factory returns at runtime so the emit and no-emit
+ * paths stay structurally aligned.
+ *
+ * The output type is intentionally `unknown` — the precise inference is
+ * column-site-local (the no-emit `FieldOutputType` resolver reads the
+ * factory's return type from the column descriptor's `type` slot, which
+ * carries `(ctx) => Codec<…, S['infer']>`). The emit path renders the
+ * descriptor's `expression` as the column's TS type (per the descriptor's
+ * `renderOutputType`); the codec-id-keyed `CodecTypes` map is the
+ * fallback for sites without a column descriptor in scope.
+ */
+type CodecTypes = {
+  readonly 'arktype/json@1': {
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly traits: 'equality';
+  };
+};
+//#endregion
+export { CodecTypes as t };
+//# sourceMappingURL=codec-types-CH37Yc0C.d.mts.map

package/dist/codec-types-CH37Yc0C.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-CH37Yc0C.d.mts","names":[],"sources":["../src/types/codec-types.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;;;;;;;;;;KAAY,UAAA"}

package/dist/codec-types.d.mts

@@ -0,0 +1,2 @@
+import { t as CodecTypes } from "./codec-types-CH37Yc0C.mjs";
+export { type CodecTypes };

package/dist/codec-types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/codecs.d.mts

@@ -0,0 +1,2 @@
+import { i as ArktypeJsonTypeParams, n as ARKTYPE_JSON_NATIVE_TYPE, o as arktypeJsonCodec, r as ArktypeJsonCodec, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-yNv1hzBm.mjs";
+export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, type ArktypeJsonCodec, type ArktypeJsonTypeParams, arktypeJsonCodec };

package/dist/codecs.mjs

@@ -0,0 +1,3 @@
+import { i as arktypeJsonCodec, n as ARKTYPE_JSON_NATIVE_TYPE, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
+
+export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, arktypeJsonCodec };

package/dist/column-types.d.mts

@@ -0,0 +1,2 @@
+import { a as arktypeJson, i as ArktypeJsonTypeParams, r as ArktypeJsonCodec } from "./arktype-json-codec-yNv1hzBm.mjs";
+export { type ArktypeJsonCodec, type ArktypeJsonTypeParams, arktypeJson };

package/dist/column-types.mjs

@@ -0,0 +1,3 @@
+import { r as arktypeJson } from "./arktype-json-codec-BbiBmtTK.mjs";
+
+export { arktypeJson };

package/dist/control.d.mts

@@ -0,0 +1,8 @@
+import { SqlControlExtensionDescriptor } from "@prisma-next/family-sql/control";
+
+//#region src/exports/control.d.ts
+
+declare const arktypeJsonExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>;
+//#endregion
+export { arktypeJsonExtensionDescriptor, arktypeJsonExtensionDescriptor as default };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;cA0Ba,gCAAgC"}

package/dist/control.mjs

@@ -0,0 +1,24 @@
+import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-DycetSQB.mjs";
+
+//#region src/exports/control.ts
+const arktypeJsonControlPlaneHooks = { expandNativeType: ({ nativeType }) => nativeType };
+const arktypeJsonExtensionDescriptor = {
+	...arktypeJsonPackMeta,
+	types: {
+		...arktypeJsonPackMeta.types,
+		codecTypes: {
+			...arktypeJsonPackMeta.types.codecTypes,
+			controlPlaneHooks: { [ARKTYPE_JSON_CODEC_ID]: arktypeJsonControlPlaneHooks }
+		}
+	},
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+var control_default = arktypeJsonExtensionDescriptor;
+
+//#endregion
+export { arktypeJsonExtensionDescriptor, control_default as default };
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":["arktypeJsonControlPlaneHooks: CodecControlHooks","arktypeJsonExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>"],"sources":["../src/exports/control.ts"],"sourcesContent":["/**\n * Control-plane extension descriptor for arktype-json.\n *\n * Composes pack metadata and the control-plane hooks into the migration-\n * plane shape the framework's control stack consumes. Lives at the\n * control-plane entrypoint so `src/core/**` stays free of migration-plane\n * imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).\n *\n * Unlike pgvector, arktype-json has no database extension to install\n * (`jsonb` is a built-in Postgres type), no `databaseDependencies`, no\n * query operations, and the only control-plane hook is the identity\n * `expandNativeType` (jsonb is dimension-free; the schema in typeParams\n * affects runtime validation only, never DDL).\n */\n\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { ARKTYPE_JSON_CODEC_ID } from '../core/arktype-json-codec';\nimport { arktypeJsonPackMeta } from '../core/pack-meta';\n\nconst arktypeJsonControlPlaneHooks: CodecControlHooks = {\n  expandNativeType: ({ nativeType }) => nativeType,\n};\n\nexport const arktypeJsonExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...arktypeJsonPackMeta,\n  types: {\n    ...arktypeJsonPackMeta.types,\n    codecTypes: {\n      ...arktypeJsonPackMeta.types.codecTypes,\n      controlPlaneHooks: {\n        [ARKTYPE_JSON_CODEC_ID]: arktypeJsonControlPlaneHooks,\n      },\n    },\n  },\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport default arktypeJsonExtensionDescriptor;\n"],"mappings":";;;;AAsBA,MAAMA,+BAAkD,EACtD,mBAAmB,EAAE,iBAAiB,YACvC;AAED,MAAaC,iCAA4E;CACvF,GAAG;CACH,OAAO;EACL,GAAG,oBAAoB;EACvB,YAAY;GACV,GAAG,oBAAoB,MAAM;GAC7B,mBAAmB,GAChB,wBAAwB,8BAC1B;GACF;EACF;CACD,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF;AAED,sBAAe"}

package/dist/pack-meta-DycetSQB.mjs

@@ -0,0 +1,37 @@
+import { a as arktypeJsonEmitCodec, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
+
+//#region src/core/pack-meta.ts
+const arktypeJsonPackMetaBase = {
+	kind: "extension",
+	id: "arktype-json",
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.0.1",
+	capabilities: {},
+	types: {
+		codecTypes: {
+			codecInstances: [arktypeJsonEmitCodec],
+			import: {
+				package: "@prisma-next/extension-arktype-json/codec-types",
+				named: "CodecTypes",
+				alias: "ArktypeJsonTypes"
+			}
+		},
+		storage: [{
+			typeId: ARKTYPE_JSON_CODEC_ID,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: "jsonb"
+		}]
+	}
+};
+/**
+* Public pack metadata. The phantom `__codecTypes` field threads the
+* codec-types map's literal type into the pack ref so contract-builder
+* generics can pick it up; it is never accessed at runtime.
+*/
+const arktypeJsonPackMeta = arktypeJsonPackMetaBase;
+
+//#endregion
+export { arktypeJsonPackMeta as t };
+//# sourceMappingURL=pack-meta-DycetSQB.mjs.map

package/dist/pack-meta-DycetSQB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-meta-DycetSQB.mjs","names":["arktypeJsonPackMeta: typeof arktypeJsonPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/pack-meta.ts"],"sourcesContent":["/**\n * arktype-json pack metadata.\n *\n * The pack metadata is the framework-composition entry point: control-\n * stack assembly reads `types.codecTypes.import` to thread the type-side\n * imports into emitted `contract.d.ts`, and `types.storage` declares the\n * codec id's storage backing (`jsonb` on Postgres).\n *\n * Per Phase B of codec-registry-unification, runtime materialization\n * flows through the unified descriptor map (`arktypeJsonCodec`\n * parameterized descriptor), not through the legacy runtime codec\n * lookup. This metadata still carries an emit-only `Codec` instance\n * (`arktypeJsonEmitCodec`) under `codecInstances` so the framework\n * emitter's codec-id-keyed `CodecLookup` can resolve `renderOutputType`\n * at emit time — that shim retires when the emit path consults the\n * descriptor map directly (TML-2357). Control-stack consumers read\n * codec metadata from `descriptorFor('arktype/json@1')`.\n */\n\nimport type { CodecTypes } from '../types/codec-types';\nimport { ARKTYPE_JSON_CODEC_ID, arktypeJsonEmitCodec } from './arktype-json-codec';\n\nconst arktypeJsonPackMetaBase = {\n  kind: 'extension',\n  id: 'arktype-json',\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n  types: {\n    codecTypes: {\n      // The emitter's `CodecLookup` is the codec-id-keyed source of\n      // truth for `renderOutputType` at the framework emit-path\n      // boundary. We thread an emit-only `Codec` instance carrying the\n      // `renderOutputType` here so the lookup resolves; runtime\n      // materialization goes through the unified descriptor's\n      // `factory: (P) => (CodecInstanceContext) => Codec`, never through this shim.\n      codecInstances: [arktypeJsonEmitCodec],\n      import: {\n        package: '@prisma-next/extension-arktype-json/codec-types',\n        named: 'CodecTypes',\n        alias: 'ArktypeJsonTypes',\n      },\n    },\n    storage: [\n      {\n        typeId: ARKTYPE_JSON_CODEC_ID,\n        familyId: 'sql' as const,\n        targetId: 'postgres' as const,\n        nativeType: 'jsonb',\n      },\n    ],\n  },\n} as const;\n\n/**\n * Public pack metadata. The phantom `__codecTypes` field threads the\n * codec-types map's literal type into the pack ref so contract-builder\n * generics can pick it up; it is never accessed at runtime.\n */\nexport const arktypeJsonPackMeta: typeof arktypeJsonPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = arktypeJsonPackMetaBase;\n"],"mappings":";;;AAsBA,MAAM,0BAA0B;CAC9B,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,cAAc,EAAE;CAChB,OAAO;EACL,YAAY;GAOV,gBAAgB,CAAC,qBAAqB;GACtC,QAAQ;IACN,SAAS;IACT,OAAO;IACP,OAAO;IACR;GACF;EACD,SAAS,CACP;GACE,QAAQ;GACR,UAAU;GACV,UAAU;GACV,YAAY;GACb,CACF;EACF;CACF;;;;;;AAOD,MAAaA,sBAET"}

package/dist/pack.d.mts

@@ -0,0 +1,40 @@
+import { t as CodecTypes } from "./codec-types-CH37Yc0C.mjs";
+import * as _prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
+
+//#region src/core/pack-meta.d.ts
+
+declare const arktypeJsonPackMetaBase: {
+  readonly kind: "extension";
+  readonly id: "arktype-json";
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  readonly version: "0.0.1";
+  readonly capabilities: {};
+  readonly types: {
+    readonly codecTypes: {
+      readonly codecInstances: readonly [_prisma_next_framework_components_codec0.Codec<"arktype/json@1", readonly ["equality"], string, unknown>];
+      readonly import: {
+        readonly package: "@prisma-next/extension-arktype-json/codec-types";
+        readonly named: "CodecTypes";
+        readonly alias: "ArktypeJsonTypes";
+      };
+    };
+    readonly storage: readonly [{
+      readonly typeId: "arktype/json@1";
+      readonly familyId: "sql";
+      readonly targetId: "postgres";
+      readonly nativeType: "jsonb";
+    }];
+  };
+};
+/**
+ * Public pack metadata. The phantom `__codecTypes` field threads the
+ * codec-types map's literal type into the pack ref so contract-builder
+ * generics can pick it up; it is never accessed at runtime.
+ */
+declare const arktypeJsonPackMeta: typeof arktypeJsonPackMetaBase & {
+  readonly __codecTypes?: CodecTypes;
+};
+//#endregion
+export { arktypeJsonPackMeta, arktypeJsonPackMeta as default };
+//# sourceMappingURL=pack.d.mts.map