@prisma-next/extension-arktype-json 0.5.0-dev.60 → 0.5.0-dev.61

package/README.md

@@ -1,33 +1,19 @@
 # `@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.
+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:
+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 }`).
+- 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).
+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
 
@@ -51,14 +37,11 @@ const contract = defineContract({ /* ... */ }, ({ field, model }) => ({
 }));
 ```
 
-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.
+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`:
+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';
@@ -80,12 +63,6 @@ const stack = createSqlExecutionStack({
 
 ## 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.
+- 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. JSON-Schema validation lives uniformly inside the resolved codec's `decode` body; the framework no longer maintains a parallel validator registry. Validation rejections surface as `RUNTIME.DECODE_FAILED` envelopes with the original `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` attached on `cause`.
+- For untyped raw JSON columns, use `jsonColumn` / `jsonbColumn` from `@prisma-next/adapter-postgres/column-types` instead.

package/dist/arktype-json-codec-Cykol-li.mjs

@@ -0,0 +1,120 @@
+import { CodecDescriptorImpl, CodecImpl, column } from "@prisma-next/framework-components/codec";
+import { runtimeError } from "@prisma-next/framework-components/runtime";
+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";
+function isArktypeSchemaLike(value) {
+	if (typeof value !== "function") return false;
+	return typeof value.expression === "string";
+}
+function validateSchema(schema, 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(schema, 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(schema, json);
+	return {
+		wire,
+		json
+	};
+}
+function rehydrateSchema(jsonIr) {
+	let rehydrated;
+	try {
+		rehydrated = ark.schema(jsonIr);
+	} catch (error) {
+		throw runtimeError(
+			"RUNTIME.JSON_SCHEMA_VALIDATION_FAILED",
+			/* c8 ignore next — the `String(error)` fallback covers throws of non-Error values; arktype only throws Error subclasses, so this branch is defensive only. */
+			`Failed to rehydrate arktype schema from contract IR: ${error instanceof Error ? error.message : String(error)}`,
+			{
+				codecId: ARKTYPE_JSON_CODEC_ID,
+				jsonIr
+			}
+		);
+	}
+	/* c8 ignore start — defensive: ark.schema either throws (handled above) or returns a callable Type with `expression: string`. The structural guard is kept so a future ark internal change can't silently slip a non-callable past us. */
+	if (!isArktypeSchemaLike(rehydrated)) throw runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `Rehydrated arktype schema does not have the expected callable + 'expression: string' shape (codecId: ${ARKTYPE_JSON_CODEC_ID})`, {
+		codecId: ARKTYPE_JSON_CODEC_ID,
+		jsonIr
+	});
+	/* c8 ignore stop */
+	return rehydrated;
+}
+function renderArktypeJsonOutputType(params) {
+	const expression = params.expression.trim();
+	return expression.length > 0 ? expression : "unknown";
+}
+var ArktypeJsonCodecClass = class extends CodecImpl {
+	constructor(descriptor, schema) {
+		super(descriptor);
+		this.schema = schema;
+	}
+	async encode(value, _ctx) {
+		return serializeToJsonSafe(this.schema, value).wire;
+	}
+	async decode(wire, _ctx) {
+		return validateSchema(this.schema, JSON.parse(wire));
+	}
+	encodeJson(value) {
+		return serializeToJsonSafe(this.schema, value).json;
+	}
+	decodeJson(json) {
+		return validateSchema(this.schema, json);
+	}
+};
+const arktypeJsonParamsSchema = type({
+	expression: "string",
+	jsonIr: "object"
+});
+var ArktypeJsonDescriptor = class extends CodecDescriptorImpl {
+	codecId = ARKTYPE_JSON_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = [ARKTYPE_JSON_NATIVE_TYPE];
+	paramsSchema = arktypeJsonParamsSchema;
+	renderOutputType(params) {
+		return renderArktypeJsonOutputType(params);
+	}
+	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 () => new ArktypeJsonCodecClass(this, schema);
+	}
+};
+const arktypeJsonDescriptor = new ArktypeJsonDescriptor();
+/**
+* Per-codec column helper for `arktype/json@1`. Method-level generic over `S extends Type<unknown>` so the column site preserves the schema's inferred TS type in the resolved codec (`ArktypeJsonCodecClass<S['infer']>`). Bypasses `descriptor.factory` because `S` is only available at the column-author site; constructs the typed codec directly with the closure-captured schema.
+*
+* Eager serialization at this call site captures `expression` (for the emit-path renderer) and `jsonIr` (for runtime rehydration via the descriptor's factory).
+*
+* @throws {Error} if the schema doesn't expose `expression` and `json` fields (i.e. is not an arktype `Type`). Validates the schema shape at the call site so configuration errors surface during contract authoring, not at runtime.
+*/
+function arktypeJsonColumn(schema) {
+	if (!isArktypeSchemaLike(schema)) throw new Error(typeof schema !== "function" ? "arktypeJsonColumn(schema) expects a callable arktype Type." : "arktypeJsonColumn(schema) expects an arktype Type (missing `expression: string`).");
+	const jsonIr = schema.json;
+	if (jsonIr === null || typeof jsonIr !== "object") throw new Error("arktypeJsonColumn(schema) expects an arktype Type (missing `json` IR).");
+	const params = {
+		expression: schema.expression,
+		jsonIr
+	};
+	return column((_ctx) => new ArktypeJsonCodecClass(arktypeJsonDescriptor, schema), arktypeJsonDescriptor.codecId, params, ARKTYPE_JSON_NATIVE_TYPE);
+}
+const codecDescriptors = [arktypeJsonDescriptor];
+
+//#endregion
+export { codecDescriptors as i, ARKTYPE_JSON_NATIVE_TYPE as n, arktypeJsonColumn as r, ARKTYPE_JSON_CODEC_ID as t };
+//# sourceMappingURL=arktype-json-codec-Cykol-li.mjs.map

package/dist/arktype-json-codec-Cykol-li.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-Cykol-li.mjs","names":["wire: string | undefined","rehydrated: unknown","schema: ArktypeSchemaLike","jsonIr: unknown","params: ArktypeJsonTypeParams","codecDescriptors: readonly AnyCodecDescriptor[]"],"sources":["../src/core/arktype-json-codec.ts"],"sourcesContent":["/**\n * Arktype-json codec (TML-2357).\n *\n * Spec § Case 3: method-level generic over `S extends Type<unknown>`. The schema's TypeScript-level inferred type `S['infer']` is only available at the column-author site (where the user passes their typed schema), not at the descriptor's factory site (where only the serialized IR is available). This drives the shape:\n *\n * 1. {@link ArktypeJsonCodecClass} extends {@link CodecImpl} and is generic over `TInferred` — the application-level JS type the schema validates to. The constructor takes both the descriptor (for `id` proxy) and the rehydrated arktype `Type` (closure-captured so encode/decode/encodeJson/decodeJson can validate through it). 2. {@link ArktypeJsonDescriptor} extends {@link CodecDescriptorImpl} over {@link\n * ArktypeJsonTypeParams}. Factory rehydrates the schema from `params.jsonIr` and returns `(ctx) => new ArktypeJsonCodecClass<unknown>(this, schema)` — `S` is erased to `unknown` because the descriptor only sees IR. The runtime path through `descriptor.factory(params)` always exists (e.g. for `validateContract` re-materialization); it just loses the typed inferred shape. 3. {@link arktypeJsonColumn} is the column-author\n * surface with the method-level generic over `S extends Type<unknown>`. It bypasses `descriptor.factory` because `S` is only available here, instead constructing the typed codec directly so `S['infer']` flows through `codecFactory`'s return into the column site's resolved output type. Eager serialization at this call site captures `expression` (for the emit-path renderer) and `jsonIr` (for runtime rehydration).\n *\n * `satisfies ColumnHelperFor<ArktypeJsonDescriptor>` (coarse) is applied — the typeParams shape is verified. `ColumnHelperForStrict` is intentionally skipped: the descriptor's factory return is `ArktypeJsonCodecClass<unknown>` while the helper produces `ArktypeJsonCodecClass<S['infer']>`, and `Codec`'s `TInput` is invariant (used contravariantly in `encode`, covariantly in `decode`/`encodeJson`/`decodeJson`). Strict\n * assignment fails by design; the explicit `expectTypeOf` tests in `test/arktype-json-codec.types.test-d.ts` cover the literal-preservation property the strict variant would otherwise enforce.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n  type AnyCodecDescriptor,\n  type CodecCallContext,\n  CodecDescriptorImpl,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnSpec,\n  column,\n} from '@prisma-next/framework-components/codec';\nimport { runtimeError } from '@prisma-next/framework-components/runtime';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { ArkErrors, ark, type Type, type } from 'arktype';\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/**\n * 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`.\n */\nexport type ArktypeJsonTypeParams = {\n  /**\n   * 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.\n   */\n  readonly expression: string;\n  /**\n   * 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.\n   */\n  readonly jsonIr: object;\n};\n\ntype ArktypeSchemaLike = ((value: unknown) => unknown) & {\n  readonly expression: string;\n};\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\nfunction validateSchema<TInferred>(schema: ArktypeSchemaLike, 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  return result as TInferred;\n}\n\nfunction serializeToJsonSafe<TInferred>(\n  schema: ArktypeSchemaLike,\n  value: TInferred,\n): { wire: string; json: JsonValue } {\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  validateSchema(schema, json);\n  return { wire, json };\n}\n\nfunction rehydrateSchema(jsonIr: object): ArktypeSchemaLike {\n  let rehydrated: unknown;\n  try {\n    rehydrated = ark.schema(jsonIr);\n  } catch (error) {\n    throw runtimeError(\n      'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',\n      /* c8 ignore next — the `String(error)` fallback covers throws of non-Error values; arktype only throws Error subclasses, so this branch is defensive only. */\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  /* c8 ignore start — defensive: ark.schema either throws (handled above) or returns a callable Type with `expression: string`. The structural guard is kept so a future ark internal change can't silently slip a non-callable past us. */\n  if (!isArktypeSchemaLike(rehydrated)) {\n    throw runtimeError(\n      'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',\n      `Rehydrated arktype schema does not have the expected callable + 'expression: string' shape (codecId: ${ARKTYPE_JSON_CODEC_ID})`,\n      { codecId: ARKTYPE_JSON_CODEC_ID, jsonIr },\n    );\n  }\n  /* c8 ignore stop */\n  return rehydrated;\n}\n\nfunction renderArktypeJsonOutputType(params: ArktypeJsonTypeParams): string {\n  const expression = params.expression.trim();\n  return expression.length > 0 ? expression : 'unknown';\n}\n\nexport class ArktypeJsonCodecClass<TInferred> extends CodecImpl<\n  typeof ARKTYPE_JSON_CODEC_ID,\n  readonly ['equality'],\n  string,\n  TInferred\n> {\n  constructor(\n    descriptor: ArktypeJsonDescriptor,\n    private readonly schema: ArktypeSchemaLike,\n  ) {\n    super(descriptor);\n  }\n\n  async encode(value: TInferred, _ctx: CodecCallContext): Promise<string> {\n    return serializeToJsonSafe(this.schema, value).wire;\n  }\n\n  async decode(wire: string, _ctx: CodecCallContext): Promise<TInferred> {\n    return validateSchema<TInferred>(this.schema, JSON.parse(wire));\n  }\n\n  encodeJson(value: TInferred): JsonValue {\n    return serializeToJsonSafe(this.schema, value).json;\n  }\n\n  decodeJson(json: JsonValue): TInferred {\n    return validateSchema<TInferred>(this.schema, json);\n  }\n}\n\nconst arktypeJsonParamsSchema = type({\n  expression: 'string',\n  jsonIr: 'object',\n}) satisfies StandardSchemaV1<ArktypeJsonTypeParams>;\n\nexport class ArktypeJsonDescriptor extends CodecDescriptorImpl<ArktypeJsonTypeParams> {\n  override readonly codecId = ARKTYPE_JSON_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = [ARKTYPE_JSON_NATIVE_TYPE] as const;\n  override readonly paramsSchema: StandardSchemaV1<ArktypeJsonTypeParams> = arktypeJsonParamsSchema;\n  override renderOutputType(params: ArktypeJsonTypeParams): string {\n    return renderArktypeJsonOutputType(params);\n  }\n  override factory(\n    params: ArktypeJsonTypeParams,\n  ): (ctx: CodecInstanceContext) => ArktypeJsonCodecClass<unknown> {\n    const schema = rehydrateSchema(params.jsonIr);\n    /* c8 ignore start — defensive parity check; not exercised by typical contracts */\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 () => new ArktypeJsonCodecClass<unknown>(this, schema);\n  }\n}\n\nexport const arktypeJsonDescriptor = new ArktypeJsonDescriptor();\n\n/**\n * Per-codec column helper for `arktype/json@1`. Method-level generic over `S extends Type<unknown>` so the column site preserves the schema's inferred TS type in the resolved codec (`ArktypeJsonCodecClass<S['infer']>`). Bypasses `descriptor.factory` because `S` is only available at the column-author site; constructs the typed codec directly with the closure-captured schema.\n *\n * Eager serialization at this call site captures `expression` (for the emit-path renderer) and `jsonIr` (for runtime rehydration via the descriptor's factory).\n *\n * @throws {Error} if the schema doesn't expose `expression` and `json` fields (i.e. is not an arktype `Type`). Validates the schema shape at the call site so configuration errors surface during contract authoring, not at runtime.\n */\nexport function arktypeJsonColumn<S extends Type<unknown>>(\n  schema: S,\n): ColumnSpec<ArktypeJsonCodecClass<S['infer']>, ArktypeJsonTypeParams> {\n  if (!isArktypeSchemaLike(schema)) {\n    throw new Error(\n      typeof schema !== 'function'\n        ? 'arktypeJsonColumn(schema) expects a callable arktype Type.'\n        : 'arktypeJsonColumn(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('arktypeJsonColumn(schema) expects an arktype Type (missing `json` IR).');\n  }\n  const params: ArktypeJsonTypeParams = { expression: schema.expression, jsonIr };\n  return column(\n    (_ctx: CodecInstanceContext) =>\n      new ArktypeJsonCodecClass<S['infer']>(arktypeJsonDescriptor, schema),\n    arktypeJsonDescriptor.codecId,\n    params,\n    ARKTYPE_JSON_NATIVE_TYPE,\n  );\n}\n\narktypeJsonColumn satisfies ColumnHelperFor<ArktypeJsonDescriptor>;\n// Note: `ColumnHelperForStrict` is intentionally not applied — `Codec` is invariant in `TInput` (encode contravariant, decode covariant), so `ArktypeJsonCodecClass<S['infer']>` is not assignable to `ArktypeJsonCodecClass<unknown>` (the descriptor.factory return). `expectTypeOf` tests cover the literal-preservation property strict satisfies would otherwise enforce.\n\n/**\n * Codec instance returned by `arktypeJsonColumn(schema).codecFactory(ctx)` and by `arktypeJsonDescriptor.factory(typeParams)(ctx)`. The `TInferred` slot carries the arktype schema's inferred output type at the column-author site; descriptor-side factories erase to `unknown`.\n */\nexport type ArktypeJsonCodec<TInferred> = ArktypeJsonCodecClass<TInferred>;\n\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = [arktypeJsonDescriptor];\n"],"mappings":";;;;;;AA6BA,MAAa,wBAAwB;;AAGrC,MAAa,2BAA2B;AAoBxC,SAAS,oBAAoB,OAA4C;AACvE,KAAI,OAAO,UAAU,WAAY,QAAO;AAExC,QAAO,OADa,MAA4C,eACnC;;AAG/B,SAAS,eAA0B,QAA2B,OAA2B;CACvF,MAAM,SAAS,OAAO,MAAM;AAC5B,KAAI,kBAAkB,UACpB,OAAM,aACJ,yCACA,mDAAmD,OAAO,WAC1D;EAAE,SAAS;EAAuB,QAAQ,OAAO;EAAS,CAC3D;AAEH,QAAO;;AAGT,SAAS,oBACP,QACA,OACmC;CACnC,MAAMA,OAA2B,KAAK,UAAU,MAAM;AACtD,KAAI,OAAO,SAAS,SAClB,OAAM,aACJ,yCACA,6DAA6D,sBAAsB,IACnF,EAAE,SAAS,uBAAuB,CACnC;CAEH,MAAM,OAAO,KAAK,MAAM,KAAK;AAC7B,gBAAe,QAAQ,KAAK;AAC5B,QAAO;EAAE;EAAM;EAAM;;AAGvB,SAAS,gBAAgB,QAAmC;CAC1D,IAAIC;AACJ,KAAI;AACF,eAAa,IAAI,OAAO,OAAO;UACxB,OAAO;AACd,QAAM;GACJ;;GAEA,wDAAwD,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC9G;IAAE,SAAS;IAAuB;IAAQ;GAC3C;;;AAGH,KAAI,CAAC,oBAAoB,WAAW,CAClC,OAAM,aACJ,yCACA,wGAAwG,sBAAsB,IAC9H;EAAE,SAAS;EAAuB;EAAQ,CAC3C;;AAGH,QAAO;;AAGT,SAAS,4BAA4B,QAAuC;CAC1E,MAAM,aAAa,OAAO,WAAW,MAAM;AAC3C,QAAO,WAAW,SAAS,IAAI,aAAa;;AAG9C,IAAa,wBAAb,cAAsD,UAKpD;CACA,YACE,YACA,AAAiBC,QACjB;AACA,QAAM,WAAW;EAFA;;CAKnB,MAAM,OAAO,OAAkB,MAAyC;AACtE,SAAO,oBAAoB,KAAK,QAAQ,MAAM,CAAC;;CAGjD,MAAM,OAAO,MAAc,MAA4C;AACrE,SAAO,eAA0B,KAAK,QAAQ,KAAK,MAAM,KAAK,CAAC;;CAGjE,WAAW,OAA6B;AACtC,SAAO,oBAAoB,KAAK,QAAQ,MAAM,CAAC;;CAGjD,WAAW,MAA4B;AACrC,SAAO,eAA0B,KAAK,QAAQ,KAAK;;;AAIvD,MAAM,0BAA0B,KAAK;CACnC,YAAY;CACZ,QAAQ;CACT,CAAC;AAEF,IAAa,wBAAb,cAA2C,oBAA2C;CACpF,AAAkB,UAAU;CAC5B,AAAkB,SAAS,CAAC,WAAW;CACvC,AAAkB,cAAc,CAAC,yBAAyB;CAC1D,AAAkB,eAAwD;CAC1E,AAAS,iBAAiB,QAAuC;AAC/D,SAAO,4BAA4B,OAAO;;CAE5C,AAAS,QACP,QAC+D;EAC/D,MAAM,SAAS,gBAAgB,OAAO,OAAO;;EAE7C,MAAM,uBAAwB,OAA6C;AAC3E,MAAI,OAAO,yBAAyB,YAAY,yBAAyB,OAAO,WAC9E,SAAQ,KACN,yCAAyC,OAAO,WAAW,iDAAiD,qBAAqB,+DAClI;;AAGH,eAAa,IAAI,sBAA+B,MAAM,OAAO;;;AAIjE,MAAa,wBAAwB,IAAI,uBAAuB;;;;;;;;AAShE,SAAgB,kBACd,QACsE;AACtE,KAAI,CAAC,oBAAoB,OAAO,CAC9B,OAAM,IAAI,MACR,OAAO,WAAW,aACd,+DACA,oFACL;CAEH,MAAMC,SAAmB,OAAuC;AAChE,KAAI,WAAW,QAAQ,OAAO,WAAW,SACvC,OAAM,IAAI,MAAM,yEAAyE;CAE3F,MAAMC,SAAgC;EAAE,YAAY,OAAO;EAAY;EAAQ;AAC/E,QAAO,QACJ,SACC,IAAI,sBAAkC,uBAAuB,OAAO,EACtE,sBAAsB,SACtB,QACA,yBACD;;AAWH,MAAaC,mBAAkD,CAAC,sBAAsB"}

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

@@ -0,0 +1,58 @@
+import { CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext, ColumnSpec } from "@prisma-next/framework-components/codec";
+import { Type } from "arktype";
+import { JsonValue } from "@prisma-next/contract/types";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#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;
+};
+type ArktypeSchemaLike = ((value: unknown) => unknown) & {
+  readonly expression: string;
+};
+declare class ArktypeJsonCodecClass<TInferred> extends CodecImpl<typeof ARKTYPE_JSON_CODEC_ID, readonly ['equality'], string, TInferred> {
+  private readonly schema;
+  constructor(descriptor: ArktypeJsonDescriptor, schema: ArktypeSchemaLike);
+  encode(value: TInferred, _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<TInferred>;
+  encodeJson(value: TInferred): JsonValue;
+  decodeJson(json: JsonValue): TInferred;
+}
+declare class ArktypeJsonDescriptor extends CodecDescriptorImpl<ArktypeJsonTypeParams> {
+  readonly codecId: "arktype/json@1";
+  readonly traits: readonly ["equality"];
+  readonly targetTypes: readonly ["jsonb"];
+  readonly paramsSchema: StandardSchemaV1<ArktypeJsonTypeParams>;
+  renderOutputType(params: ArktypeJsonTypeParams): string;
+  factory(params: ArktypeJsonTypeParams): (ctx: CodecInstanceContext) => ArktypeJsonCodecClass<unknown>;
+}
+/**
+ * Per-codec column helper for `arktype/json@1`. Method-level generic over `S extends Type<unknown>` so the column site preserves the schema's inferred TS type in the resolved codec (`ArktypeJsonCodecClass<S['infer']>`). Bypasses `descriptor.factory` because `S` is only available at the column-author site; constructs the typed codec directly with the closure-captured schema.
+ *
+ * Eager serialization at this call site captures `expression` (for the emit-path renderer) and `jsonIr` (for runtime rehydration via the descriptor's factory).
+ *
+ * @throws {Error} if the schema doesn't expose `expression` and `json` fields (i.e. is not an arktype `Type`). Validates the schema shape at the call site so configuration errors surface during contract authoring, not at runtime.
+ */
+declare function arktypeJsonColumn<S extends Type<unknown>>(schema: S): ColumnSpec<ArktypeJsonCodecClass<S['infer']>, ArktypeJsonTypeParams>;
+/**
+ * Codec instance returned by `arktypeJsonColumn(schema).codecFactory(ctx)` and by `arktypeJsonDescriptor.factory(typeParams)(ctx)`. The `TInferred` slot carries the arktype schema's inferred output type at the column-author site; descriptor-side factories erase to `unknown`.
+ */
+type ArktypeJsonCodec<TInferred> = ArktypeJsonCodecClass<TInferred>;
+//#endregion
+export { ArktypeJsonTypeParams as a, ArktypeJsonDescriptor as i, ARKTYPE_JSON_NATIVE_TYPE as n, arktypeJsonColumn as o, ArktypeJsonCodec as r, ARKTYPE_JSON_CODEC_ID as t };
+//# sourceMappingURL=arktype-json-codec-DBfCWQkt.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-DBfCWQkt.d.mts","names":[],"sources":["../src/core/arktype-json-codec.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAiI0D,cApG7C,qBAoG6C,EAAA,gBAAA;;AAII,cArGjD,wBAqGiD,EAAA,OAAA;;;;AAQ3C,KAxGP,qBAAA,GAwGO;EAAY;;;EAUlB,SAAA,UAAA,EAAA,MAAsB;EAA4B;;;EAK3B,SAAA,MAAA,EAAA,MAAA;CAIxB;KAhHP,iBAAA,GAiHM,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,OAAA,CAAA,GAAA;EAAyB,SAAA,UAAA,EAAA,MAAA;CAVO;AAAmB,cAnCjD,qBAmCiD,CAAA,SAAA,CAAA,SAnCR,SAmCQ,CAAA,OAlCrD,qBAkCqD,EAAA,SAAA,CAAA,UAAA,CAAA,EAAA,MAAA,EA/B5D,SA+B4D,CAAA,CAAA;EAiC9C,iBAAA,MAAiB;EAAW,WAAA,CAAA,UAAA,EA7D5B,qBA6D4B,EAAA,MAAA,EA5Df,iBA4De;EAClC,MAAA,CAAA,KAAA,EAxDY,SAwDZ,EAAA,IAAA,EAxD6B,gBAwD7B,CAAA,EAxDgD,OAwDhD,CAAA,MAAA,CAAA;EAC0B,MAAA,CAAA,IAAA,EAAA,MAAA,EAAA,IAAA,EArDD,gBAqDC,CAAA,EArDkB,OAqDlB,CArD0B,SAqD1B,CAAA;EAAtB,UAAA,CAAA,KAAA,EAjDM,SAiDN,CAAA,EAjDkB,SAiDlB;EAAmC,UAAA,CAAA,IAAA,EA7C9B,SA6C8B,CAAA,EA7ClB,SA6CkB;;AAApC,cAnCA,qBAAA,SAA8B,mBAmC9B,CAnCkD,qBAmClD,CAAA,CAAA;EA4BD,SAAA,OAAA,EAAA,gBAAgB;;;yBA3DM,iBAAiB;2BACf;kBAIxB,8BACD,yBAAyB;;;;;;;;;iBAuBpB,4BAA4B,uBAClC,IACP,WAAW,sBAAsB,aAAa;;;;KA4BrC,8BAA8B,sBAAsB"}

package/dist/{codec-types-CH37Yc0C.d.mts → codec-types-5Jy4t54u.d.mts}

@@ -24,4 +24,4 @@ type CodecTypes = {
 };
 //#endregion
 export { CodecTypes as t };
-//# sourceMappingURL=codec-types-CH37Yc0C.d.mts.map
+//# sourceMappingURL=codec-types-5Jy4t54u.d.mts.map

package/dist/codec-types-5Jy4t54u.d.mts.map

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

package/dist/codec-types.d.mts

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

package/dist/codecs.d.mts

@@ -1,2 +1,14 @@
-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 };
+import { a as ArktypeJsonTypeParams, i as ArktypeJsonDescriptor, n as ARKTYPE_JSON_NATIVE_TYPE, o as arktypeJsonColumn, r as ArktypeJsonCodec, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-DBfCWQkt.mjs";
+import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
+
+//#region src/core/registry.d.ts
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/extension-arktype-json`.
+ *
+ * Public consumer surface for the arktype-json codec set. Currently a single entry (`arktype/json@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+ */
+declare const arktypeJsonCodecRegistry: CodecDescriptorRegistry;
+//#endregion
+export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, type ArktypeJsonCodec, type ArktypeJsonDescriptor, type ArktypeJsonTypeParams, arktypeJsonCodecRegistry, arktypeJsonColumn };
+//# sourceMappingURL=codecs.d.mts.map

package/dist/codecs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.d.mts","names":[],"sources":["../src/core/registry.ts"],"sourcesContent":[],"mappings":";;;;;;;;AASA;;cAAa,0BAA0B"}

package/dist/codecs.mjs

@@ -1,3 +1,4 @@
-import { i as arktypeJsonCodec, n as ARKTYPE_JSON_NATIVE_TYPE, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
+import { n as ARKTYPE_JSON_NATIVE_TYPE, r as arktypeJsonColumn, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-Cykol-li.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-DN6MqSGJ.mjs";
 
-export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, arktypeJsonCodec };
+export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, arktypeJsonCodecRegistry, arktypeJsonColumn };

package/dist/column-types.d.mts

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

package/dist/column-types.mjs

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

package/dist/control.mjs

@@ -1,5 +1,6 @@
-import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
-import { t as arktypeJsonPackMeta } from "./pack-meta-DycetSQB.mjs";
+import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-Cykol-li.mjs";
+import "./registry-DN6MqSGJ.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-BaJhoZfD.mjs";
 
 //#region src/exports/control.ts
 const arktypeJsonControlPlaneHooks = { expandNativeType: ({ nativeType }) => nativeType };

package/dist/control.mjs.map

@@ -1 +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"}
+{"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 → pack-meta-BaJhoZfD.mjs}

@@ -1,4 +1,5 @@
-import { a as arktypeJsonEmitCodec, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BbiBmtTK.mjs";
+import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-Cykol-li.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-DN6MqSGJ.mjs";
 
 //#region src/core/pack-meta.ts
 const arktypeJsonPackMetaBase = {
@@ -10,7 +11,7 @@ const arktypeJsonPackMetaBase = {
 	capabilities: {},
 	types: {
 		codecTypes: {
-			codecInstances: [arktypeJsonEmitCodec],
+			codecDescriptors: Array.from(arktypeJsonCodecRegistry.values()),
 			import: {
 				package: "@prisma-next/extension-arktype-json/codec-types",
 				named: "CodecTypes",
@@ -26,12 +27,10 @@ const arktypeJsonPackMetaBase = {
 	}
 };
 /**
-* 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.
+* 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
+//# sourceMappingURL=pack-meta-BaJhoZfD.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pack-meta-BaJhoZfD.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-stack assembly reads `types.codecTypes.import` to thread the type-side imports into emitted `contract.d.ts`, and `types.storage` declares the codec id's storage backing (`jsonb` on Postgres).\n *\n * Per TML-2357 runtime materialization flows through the unified descriptor map (`arktypeJsonDescriptor`) and the emit path consults `descriptorFor('arktype/json@1').renderOutputType` directly — no per-library \"emit-only Codec\" stub.\n */\n\nimport type { CodecTypes } from '../types/codec-types';\nimport { ARKTYPE_JSON_CODEC_ID } from './arktype-json-codec';\nimport { arktypeJsonCodecRegistry } from './registry';\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      codecDescriptors: Array.from(arktypeJsonCodecRegistry.values()),\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 codec-types map's literal type into the pack ref so contract-builder 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":";;;;AAYA,MAAM,0BAA0B;CAC9B,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,cAAc,EAAE;CAChB,OAAO;EACL,YAAY;GACV,kBAAkB,MAAM,KAAK,yBAAyB,QAAQ,CAAC;GAC/D,QAAQ;IACN,SAAS;IACT,OAAO;IACP,OAAO;IACR;GACF;EACD,SAAS,CACP;GACE,QAAQ;GACR,UAAU;GACV,UAAU;GACV,YAAY;GACb,CACF;EACF;CACF;;;;AAKD,MAAaA,sBAET"}

package/dist/pack.d.mts

@@ -1,4 +1,4 @@
-import { t as CodecTypes } from "./codec-types-CH37Yc0C.mjs";
+import { t as CodecTypes } from "./codec-types-5Jy4t54u.mjs";
 import * as _prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
 
 //#region src/core/pack-meta.d.ts
@@ -12,7 +12,7 @@ declare const arktypeJsonPackMetaBase: {
   readonly capabilities: {};
   readonly types: {
     readonly codecTypes: {
-      readonly codecInstances: readonly [_prisma_next_framework_components_codec0.Codec<"arktype/json@1", readonly ["equality"], string, unknown>];
+      readonly codecDescriptors: _prisma_next_framework_components_codec0.CodecDescriptor<unknown>[];
       readonly import: {
         readonly package: "@prisma-next/extension-arktype-json/codec-types";
         readonly named: "CodecTypes";
@@ -28,9 +28,7 @@ declare const arktypeJsonPackMetaBase: {
   };
 };
 /**
- * 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.
+ * 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;

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/pack-meta.ts"],"sourcesContent":[],"mappings":";;;;;cAsBM;;;;;;;;;yCA+BI,wCAAA,CAAA;;;;;;;;;;;;;;;;;;;;cAOG,4BAA4B;0BACf"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/pack-meta.ts"],"sourcesContent":[],"mappings":";;;;;cAYM;;;;;;;;;iCAyBI,wCAAA,CAAA;;;;;;;;;;;;;;;;;;cAKG,4BAA4B;0BACf"}

package/dist/pack.mjs

@@ -1,3 +1,5 @@
-import { t as arktypeJsonPackMeta } from "./pack-meta-DycetSQB.mjs";
+import "./arktype-json-codec-Cykol-li.mjs";
+import "./registry-DN6MqSGJ.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-BaJhoZfD.mjs";
 
 export { arktypeJsonPackMeta, arktypeJsonPackMeta as default };

package/dist/registry-DN6MqSGJ.mjs

@@ -0,0 +1,14 @@
+import { i as codecDescriptors } from "./arktype-json-codec-Cykol-li.mjs";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
+
+//#region src/core/registry.ts
+/**
+* Registry of every codec descriptor shipped by `@prisma-next/extension-arktype-json`.
+*
+* Public consumer surface for the arktype-json codec set. Currently a single entry (`arktype/json@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+*/
+const arktypeJsonCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+
+//#endregion
+export { arktypeJsonCodecRegistry as t };
+//# sourceMappingURL=registry-DN6MqSGJ.mjs.map

package/dist/registry-DN6MqSGJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry-DN6MqSGJ.mjs","names":["arktypeJsonCodecRegistry: CodecDescriptorRegistry"],"sources":["../src/core/registry.ts"],"sourcesContent":["import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';\nimport type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';\nimport { codecDescriptors } from './arktype-json-codec';\n\n/**\n * Registry of every codec descriptor shipped by `@prisma-next/extension-arktype-json`.\n *\n * Public consumer surface for the arktype-json codec set. Currently a single entry (`arktype/json@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.\n */\nexport const arktypeJsonCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n"],"mappings":";;;;;;;;;AASA,MAAaA,2BACX,6BAA6B,iBAAiB"}

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;cA0Ba,8BAA8B"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;cAYa,8BAA8B"}

package/dist/runtime.mjs

@@ -1,33 +1,15 @@
-import { i as arktypeJsonCodec } from "./arktype-json-codec-BbiBmtTK.mjs";
-import { t as arktypeJsonPackMeta } from "./pack-meta-DycetSQB.mjs";
-import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import "./arktype-json-codec-Cykol-li.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-DN6MqSGJ.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-BaJhoZfD.mjs";
 
 //#region src/exports/runtime.ts
-/**
-* Runtime-plane extension descriptor for arktype-json.
-*
-* Registers `arktypeJsonCodec` (the parameterized codec descriptor)
-* through the SQL runtime's `parameterizedCodecs:` slot. Per Phase B of
-* codec-registry-unification, the legacy `codecs:` slot returns an empty
-* registry — the unified descriptor map subsumes the codec-id-keyed
-* metadata reads that the legacy slot used to back, and the runtime
-* dispatch (`forColumn`) materializes the per-instance codec from the
-* descriptor's factory.
-*
-* Lives at the runtime-plane entrypoint so `src/core/**` stays free of
-* runtime-plane imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).
-*/
-function createArktypeJsonCodecRegistry() {
-	return createCodecRegistry();
-}
 const arktypeJsonRuntimeDescriptor = {
 	kind: "extension",
 	id: arktypeJsonPackMeta.id,
 	version: arktypeJsonPackMeta.version,
 	familyId: "sql",
 	targetId: "postgres",
-	codecs: createArktypeJsonCodecRegistry,
-	parameterizedCodecs: () => [arktypeJsonCodec],
+	codecs: () => Array.from(arktypeJsonCodecRegistry.values()),
 	create() {
 		return {
 			familyId: "sql",

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["/**\n * Runtime-plane extension descriptor for arktype-json.\n *\n * Registers `arktypeJsonCodec` (the parameterized codec descriptor)\n * through the SQL runtime's `parameterizedCodecs:` slot. Per Phase B of\n * codec-registry-unification, the legacy `codecs:` slot returns an empty\n * registry — the unified descriptor map subsumes the codec-id-keyed\n * metadata reads that the legacy slot used to back, and the runtime\n * dispatch (`forColumn`) materializes the per-instance codec from the\n * descriptor's factory.\n *\n * Lives at the runtime-plane entrypoint so `src/core/**` stays free of\n * runtime-plane imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).\n */\n\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';\nimport { arktypeJsonCodec } from '../core/arktype-json-codec';\nimport { arktypeJsonPackMeta } from '../core/pack-meta';\n\nfunction createArktypeJsonCodecRegistry() {\n  // arktype-json ships only the parameterized descriptor; the legacy\n  // `codecs:` slot has nothing to register.\n  return createCodecRegistry();\n}\n\nexport const arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: arktypeJsonPackMeta.id,\n  version: arktypeJsonPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  codecs: createArktypeJsonCodecRegistry,\n  parameterizedCodecs: () => [arktypeJsonCodec],\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport default arktypeJsonRuntimeDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,SAAS,iCAAiC;AAGxC,QAAO,qBAAqB;;AAG9B,MAAaA,+BAA0E;CACrF,MAAM;CACN,IAAI,oBAAoB;CACxB,SAAS,oBAAoB;CAC7B,UAAU;CACV,UAAU;CACV,QAAQ;CACR,2BAA2B,CAAC,iBAAiB;CAC7C,SAAS;AACP,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":["arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["/**\n * Runtime-plane extension descriptor for arktype-json.\n *\n * Registers `arktypeJsonCodec` (the unified `CodecDescriptor`) through the SQL runtime's `codecs:` slot. Per TML-2357 the dedicated parameterized-codec slot retired — the unified descriptor map dispatches every codec id, parameterized or not.\n *\n * Lives at the runtime-plane entrypoint so `src/core/**` stays free of runtime-plane imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).\n */\n\nimport type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';\nimport { arktypeJsonPackMeta } from '../core/pack-meta';\nimport { arktypeJsonCodecRegistry } from '../core/registry';\n\nexport const arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: arktypeJsonPackMeta.id,\n  version: arktypeJsonPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  codecs: () => Array.from(arktypeJsonCodecRegistry.values()),\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport default arktypeJsonRuntimeDescriptor;\n"],"mappings":";;;;;AAYA,MAAaA,+BAA0E;CACrF,MAAM;CACN,IAAI,oBAAoB;CACxB,SAAS,oBAAoB;CAC7B,UAAU;CACV,UAAU;CACV,cAAc,MAAM,KAAK,yBAAyB,QAAQ,CAAC;CAC3D,SAAS;AACP,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,sBAAe"}

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@prisma-next/extension-arktype-json",
-  "version": "0.5.0-dev.60",
+  "version": "0.5.0-dev.61",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.1.29",
-    "@prisma-next/contract": "0.5.0-dev.60",
-    "@prisma-next/contract-authoring": "0.5.0-dev.60",
-    "@prisma-next/family-sql": "0.5.0-dev.60",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.60",
-    "@prisma-next/framework-components": "0.5.0-dev.60",
-    "@prisma-next/sql-runtime": "0.5.0-dev.60"
+    "@prisma-next/contract": "0.5.0-dev.61",
+    "@prisma-next/contract-authoring": "0.5.0-dev.61",
+    "@prisma-next/family-sql": "0.5.0-dev.61",
+    "@prisma-next/framework-components": "0.5.0-dev.61",
+    "@prisma-next/sql-runtime": "0.5.0-dev.61",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.61"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/sql-contract": "0.5.0-dev.60",
+    "@prisma-next/sql-contract": "0.5.0-dev.61",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"