@prisma-next/extension-arktype-json 0.6.0-dev.4 → 0.6.0-dev.6

package/README.md

@@ -9,7 +9,8 @@ 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 }`).
+- `encode` is schema-independent and only checks JSON representability; validation runs on `decode` and `decodeJson`.
+- The emitted `contract.d.ts` renders the column's TS type as the schema's `expression` (e.g. `{ name: string; price: number }`). No-emit contracts currently fall back to the base codec output type (`unknown`).
 
 ## Why a per-library extension
 
@@ -30,14 +31,13 @@ const contract = defineContract({ /* ... */ }, ({ field, model }) => ({
       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.
+After emit, `Product.spec` in `contract.d.ts` resolves to `{ name: string; price: number; description?: string }` because the schema's expression renders directly into the field type. In the no-emit TypeScript path, the column still carries `typeParams` and runtime validation, but `FieldOutputType` currently falls back to `CodecTypes['arktype/json@1']['output']` (`unknown`), so use emitted contracts when user-facing field types must preserve the arktype schema shape.
 
 ## Pack registration
 
@@ -61,8 +61,34 @@ const stack = createSqlExecutionStack({
 });
 ```
 
+## Compatibility
+
+Codec stability depends on a round-trip invariant: `ark.schema(typeParams.jsonIr).expression === typeParams.expression`. The emit-path renderer reads `expression` directly, so a contract emitted against arktype `X` and rehydrated against arktype `Y` produces correct types only as long as that invariant holds across `X→Y`.
+
+The package's `arktype` dependency is pinned to a tilde range (`~2.1.29`) — patch upgrades are accepted, minor and major upgrades are not. Bumping the range without a coordinated re-emit of every contract using `arktype/json@1` risks emit-path output going stale relative to the rehydrated runtime schema. Consumers who upgrade `arktype` outside this range should re-run `pnpm emit` and verify `contract.d.ts` matches expectations.
+
+The runtime enforces the invariant defensively: the codec's factory runs at execution-context construction time (typically when `runtime.connect()` is called), and throws `RUNTIME.TYPE_PARAMS_INVALID` if the rehydrated schema's `expression` doesn't match the serialized one. So a stale-but-shape-valid `contract.json` fails fast at startup rather than rendering wrong types in user code. The error message points at re-running `pnpm emit`.
+
 ## 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. 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`.
+- `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.JSON_SCHEMA_VALIDATION_FAILED`.
 - For untyped raw JSON columns, use `jsonColumn` / `jsonbColumn` from `@prisma-next/adapter-postgres/column-types` instead.
+
+## Data integrity: validate-on-decode, not on encode
+
+Schema validation runs only on `decode` / `decodeJson`. `encode` checks JSON representability but does not invoke the schema. This is intentional — ADR 208 keeps `encode` parameter-independent so it can be dispatched by `codecId` without resolving per-column schemas — but it has a consequence callers must plan for: **a schema-invalid write commits the row to the database, and only then fails on the read-back through `RETURNING`**.
+
+The TypeScript types prevent this at the call site, so well-typed callers are safe. The footgun is reachable only when types are bypassed (`as never`, `// @ts-ignore`, untyped data from a third-party feed, runtime drift between writers). In that case:
+
+1. `ORM.create({ ... })` calls `codec.encode` — succeeds, because encode skips the schema.
+2. `INSERT … RETURNING` runs in autocommit — the row commits to the database.
+3. Decoding the `RETURNING` payload invokes `codec.decode` — throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED`.
+4. The caller sees an error from `create`, but the bad row is now in the table and every subsequent read of it will fail the same way.
+
+If your inputs cross a type boundary you don't fully control, mitigate:
+
+- **Wrap mutations in `withTransaction`** so a `RETURNING`-decode failure rolls back the `INSERT`.
+- **Pre-validate** with `schema.allows(value)` (or `schema(value) instanceof ArkErrors`) before calling `create` / `update`.
+
+In a fully-typed application path this never fires; the warning is for the boundary where ergonomics collide with foreign data.

package/dist/{arktype-json-codec-VX9T28RG.d.mts → arktype-json-codec-BRSKEodM.d.mts}

@@ -24,11 +24,11 @@ type ArktypeJsonTypeParams = {
 type ArktypeSchemaLike = ((value: unknown) => unknown) & {
   readonly expression: string;
 };
-declare class ArktypeJsonCodecClass<TInferred> extends CodecImpl<typeof ARKTYPE_JSON_CODEC_ID, readonly ['equality'], string, TInferred> {
+declare class ArktypeJsonCodecClass<TInferred> extends CodecImpl<typeof ARKTYPE_JSON_CODEC_ID, readonly ['equality'], string | JsonValue, TInferred> {
   private readonly schema;
   constructor(descriptor: ArktypeJsonDescriptor, schema: ArktypeSchemaLike);
   encode(value: TInferred, _ctx: CodecCallContext): Promise<string>;
-  decode(wire: string, _ctx: CodecCallContext): Promise<TInferred>;
+  decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<TInferred>;
   encodeJson(value: TInferred): JsonValue;
   decodeJson(json: JsonValue): TInferred;
 }
@@ -36,6 +36,15 @@ declare class ArktypeJsonDescriptor extends CodecDescriptorImpl<ArktypeJsonTypeP
   readonly codecId: "arktype/json@1";
   readonly traits: readonly ["equality"];
   readonly targetTypes: readonly ["jsonb"];
+  readonly meta: {
+    readonly db: {
+      readonly sql: {
+        readonly postgres: {
+          readonly nativeType: "jsonb";
+        };
+      };
+    };
+  };
   readonly paramsSchema: StandardSchemaV1<ArktypeJsonTypeParams>;
   renderOutputType(params: ArktypeJsonTypeParams): string;
   factory(params: ArktypeJsonTypeParams): (ctx: CodecInstanceContext) => ArktypeJsonCodecClass<unknown>;
@@ -54,4 +63,4 @@ declare function arktypeJsonColumn<S extends Type<unknown>>(schema: S): ColumnSp
 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-VX9T28RG.d.mts.map
+//# sourceMappingURL=arktype-json-codec-BRSKEodM.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-BRSKEodM.d.mts","names":[],"sources":["../src/core/arktype-json-codec.ts"],"mappings":";;;;;;AAqCA;AAAA,cARa,qBAAA;;cAGA,wBAAA;;AAcX;;KATU,qBAAA;EAWe;;AA8G3B;EA9G2B,SAPhB,UAAA;EAqHuB;;;EAAA,SAjHvB,MAAA;AAAA;AAAA,KAGN,iBAAA,KAAsB,KAAA;EAAA,SAChB,UAAA;AAAA;AAAA,cA6GE,qBAAA,oBAAyC,SAAA,QAC7C,qBAAA,kCAEE,SAAA,EACT,SAAA;EAAA,iBAImB,MAAA;cADjB,UAAA,EAAY,qBAAA,EACK,MAAA,EAAQ,iBAAA;EAKrB,MAAA,CAAO,KAAA,EAAO,SAAA,EAAW,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAIlD,MAAA,CAAO,IAAA,WAAe,SAAA,EAAW,IAAA,EAAM,gBAAA,GAAmB,OAAA,CAAQ,SAAA;EAIxE,UAAA,CAAW,KAAA,EAAO,SAAA,GAAY,SAAA;EAI9B,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,SAAA;AAAA;AAAA,cAYlB,qBAAA,SAA8B,mBAAA,CAAoB,qBAAA;EAAA,SAC3C,OAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,IAAA;IAAA;;;;;;;;WACA,YAAA,EAAc,gBAAA,CAAiB,qBAAA;EACxC,gBAAA,CAAiB,MAAA,EAAQ,qBAAA;EAGzB,OAAA,CACP,MAAA,EAAQ,qBAAA,IACN,GAAA,EAAK,oBAAA,KAAyB,qBAAA;AAAA;;;;;;;;iBA2BpB,iBAAA,WAA4B,IAAA,UAAA,CAC1C,MAAA,EAAQ,CAAA,GACP,UAAA,CAAW,qBAAA,CAAsB,CAAA,YAAa,qBAAA;;;;KA4BrC,gBAAA,cAA8B,qBAAA,CAAsB,SAAA"}

package/dist/{arktype-json-codec-DluUG3EZ.mjs → arktype-json-codec-BjUHsoD5.mjs}

@@ -1,5 +1,5 @@
 import { CodecDescriptorImpl, CodecImpl, column } from "@prisma-next/framework-components/codec";
-import { runtimeError } from "@prisma-next/framework-components/runtime";
+import { isRuntimeError, 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. */
@@ -18,15 +18,31 @@ function validateSchema(schema, value) {
 	});
 	return result;
 }
-function serializeToJsonSafe(schema, value) {
+function serializeWire(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
-	};
+	if (typeof wire !== "string") throw new Error(`arktype-json value is not representable as JSON (codecId: ${ARKTYPE_JSON_CODEC_ID})`);
+	return wire;
+}
+function serializeJson(value) {
+	return JSON.parse(serializeWire(value));
+}
+function parseJsonText(wire) {
+	try {
+		return JSON.parse(wire);
+	} catch {
+		return;
+	}
+}
+function decodeWireValue(schema, wire) {
+	if (typeof wire !== "string") return validateSchema(schema, wire);
+	try {
+		return validateSchema(schema, wire);
+	} catch (error) {
+		if (!isRuntimeError(error) || error.code !== "RUNTIME.JSON_SCHEMA_VALIDATION_FAILED") throw error;
+		const parsed = parseJsonText(wire);
+		if (parsed === void 0) throw error;
+		return validateSchema(schema, parsed);
+	}
 }
 function rehydrateSchema(jsonIr) {
 	let rehydrated;
@@ -62,13 +78,13 @@ var ArktypeJsonCodecClass = class extends CodecImpl {
 		this.schema = schema;
 	}
 	async encode(value, _ctx) {
-		return serializeToJsonSafe(this.schema, value).wire;
+		return serializeWire(value);
 	}
 	async decode(wire, _ctx) {
-		return validateSchema(this.schema, JSON.parse(wire));
+		return decodeWireValue(this.schema, wire);
 	}
 	encodeJson(value) {
-		return serializeToJsonSafe(this.schema, value).json;
+		return serializeJson(value);
 	}
 	decodeJson(json) {
 		return validateSchema(this.schema, json);
@@ -78,20 +94,24 @@ const arktypeJsonParamsSchema = type({
 	expression: "string",
 	jsonIr: "object"
 });
+const ARKTYPE_JSON_META = { db: { sql: { postgres: { nativeType: "jsonb" } } } };
 var ArktypeJsonDescriptor = class extends CodecDescriptorImpl {
 	codecId = ARKTYPE_JSON_CODEC_ID;
 	traits = ["equality"];
 	targetTypes = [ARKTYPE_JSON_NATIVE_TYPE];
+	meta = ARKTYPE_JSON_META;
 	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 */
+		if (typeof rehydratedExpression === "string" && rehydratedExpression !== params.expression) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `arktype-json: typeParams.expression (${params.expression}) does not match the rehydrated schema's expression (${rehydratedExpression}). The contract was likely emitted against a different arktype version or hand-edited; re-run \`pnpm emit\` to regenerate.`, {
+			codecId: ARKTYPE_JSON_CODEC_ID,
+			serializedExpression: params.expression,
+			rehydratedExpression
+		});
 		return () => new ArktypeJsonCodecClass(this, schema);
 	}
 };
@@ -117,4 +137,4 @@ 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-DluUG3EZ.mjs.map
+//# sourceMappingURL=arktype-json-codec-BjUHsoD5.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arktype-json-codec-BjUHsoD5.mjs","names":[],"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 { isRuntimeError, 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 serializeWire<TInferred>(value: TInferred): string {\n  const wire: string | undefined = JSON.stringify(value);\n  if (typeof wire !== 'string') {\n    throw new Error(\n      `arktype-json value is not representable as JSON (codecId: ${ARKTYPE_JSON_CODEC_ID})`,\n    );\n  }\n  return wire;\n}\n\nfunction serializeJson<TInferred>(value: TInferred): JsonValue {\n  // The stringify → parse round-trip both validates JSON-representability\n  // (matching `serializeWire`) and produces a deep-cloned `JsonValue` that\n  // strips class prototypes / `toJSON` side effects, so callers reading\n  // the in-memory `JsonValue` see exactly the shape that would round-trip\n  // through the database.\n  return JSON.parse(serializeWire(value)) as JsonValue;\n}\n\nfunction parseJsonText(wire: string): JsonValue | undefined {\n  try {\n    return JSON.parse(wire) as JsonValue;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction decodeWireValue<TInferred>(\n  schema: ArktypeSchemaLike,\n  wire: string | JsonValue,\n): TInferred {\n  if (typeof wire !== 'string') return validateSchema<TInferred>(schema, wire);\n\n  // Try the wire as the literal value first. Under `pg` + `jsonb` (the\n  // documented native type), wire arrives already-parsed: a JSON object\n  // surfaces as a JS object, a JSON string surfaces as a JS string. For\n  // string columns that means the wire IS the user's value — including\n  // strings whose literal characters happen to start and end with `\"`.\n  // A `\"…\"`-shape unwrap heuristic would silently truncate them (the\n  // 7-char `\"hello\"` would decode to the 5-char `hello`).\n  //\n  // Fall back to JSON.parse only when schema validation rejects the raw\n  // wire: that path covers object/array shapes received as raw JSON\n  // text (legacy `json` text-OID adapters, or any code path that hands\n  // us un-pre-parsed JSON).\n  try {\n    return validateSchema<TInferred>(schema, wire);\n  } catch (error) {\n    if (!isRuntimeError(error) || error.code !== 'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED') {\n      throw error;\n    }\n    const parsed = parseJsonText(wire);\n    if (parsed === undefined) {\n      throw error;\n    }\n    return validateSchema<TInferred>(schema, parsed);\n  }\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 | JsonValue,\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 serializeWire(value);\n  }\n\n  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<TInferred> {\n    return decodeWireValue<TInferred>(this.schema, wire);\n  }\n\n  encodeJson(value: TInferred): JsonValue {\n    return serializeJson(value);\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\nconst ARKTYPE_JSON_META = { db: { sql: { postgres: { nativeType: 'jsonb' } } } } as const;\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 meta = ARKTYPE_JSON_META;\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    const rehydratedExpression = (schema as { readonly expression?: unknown }).expression;\n    if (typeof rehydratedExpression === 'string' && rehydratedExpression !== params.expression) {\n      throw runtimeError(\n        'RUNTIME.TYPE_PARAMS_INVALID',\n        `arktype-json: typeParams.expression (${params.expression}) does not match the rehydrated schema's expression (${rehydratedExpression}). The contract was likely emitted against a different arktype version or hand-edited; re-run \\`pnpm emit\\` to regenerate.`,\n        {\n          codecId: ARKTYPE_JSON_CODEC_ID,\n          serializedExpression: params.expression,\n          rehydratedExpression,\n        },\n      );\n    }\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;CACvE,IAAI,OAAO,UAAU,YAAY,OAAO;CAExC,OAAO,OADa,MAA4C,eACnC;;AAG/B,SAAS,eAA0B,QAA2B,OAA2B;CACvF,MAAM,SAAS,OAAO,MAAM;CAC5B,IAAI,kBAAkB,WACpB,MAAM,aACJ,yCACA,mDAAmD,OAAO,WAC1D;EAAE,SAAS;EAAuB,QAAQ,OAAO;EAAS,CAC3D;CAEH,OAAO;;AAGT,SAAS,cAAyB,OAA0B;CAC1D,MAAM,OAA2B,KAAK,UAAU,MAAM;CACtD,IAAI,OAAO,SAAS,UAClB,MAAM,IAAI,MACR,6DAA6D,sBAAsB,GACpF;CAEH,OAAO;;AAGT,SAAS,cAAyB,OAA6B;CAM7D,OAAO,KAAK,MAAM,cAAc,MAAM,CAAC;;AAGzC,SAAS,cAAc,MAAqC;CAC1D,IAAI;EACF,OAAO,KAAK,MAAM,KAAK;SACjB;EACN;;;AAIJ,SAAS,gBACP,QACA,MACW;CACX,IAAI,OAAO,SAAS,UAAU,OAAO,eAA0B,QAAQ,KAAK;CAc5E,IAAI;EACF,OAAO,eAA0B,QAAQ,KAAK;UACvC,OAAO;EACd,IAAI,CAAC,eAAe,MAAM,IAAI,MAAM,SAAS,yCAC3C,MAAM;EAER,MAAM,SAAS,cAAc,KAAK;EAClC,IAAI,WAAW,KAAA,GACb,MAAM;EAER,OAAO,eAA0B,QAAQ,OAAO;;;AAIpD,SAAS,gBAAgB,QAAmC;CAC1D,IAAI;CACJ,IAAI;EACF,aAAa,IAAI,OAAO,OAAO;UACxB,OAAO;EACd,MAAM;GACJ;;GAEA,wDAAwD,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC9G;IAAE,SAAS;IAAuB;IAAQ;GAC3C;;;CAGH,IAAI,CAAC,oBAAoB,WAAW,EAClC,MAAM,aACJ,yCACA,wGAAwG,sBAAsB,IAC9H;EAAE,SAAS;EAAuB;EAAQ,CAC3C;;CAGH,OAAO;;AAGT,SAAS,4BAA4B,QAAuC;CAC1E,MAAM,aAAa,OAAO,WAAW,MAAM;CAC3C,OAAO,WAAW,SAAS,IAAI,aAAa;;AAG9C,IAAa,wBAAb,cAAsD,UAKpD;CAGmB;CAFnB,YACE,YACA,QACA;EACA,MAAM,WAAW;EAFA,KAAA,SAAA;;CAKnB,MAAM,OAAO,OAAkB,MAAyC;EACtE,OAAO,cAAc,MAAM;;CAG7B,MAAM,OAAO,MAA0B,MAA4C;EACjF,OAAO,gBAA2B,KAAK,QAAQ,KAAK;;CAGtD,WAAW,OAA6B;EACtC,OAAO,cAAc,MAAM;;CAG7B,WAAW,MAA4B;EACrC,OAAO,eAA0B,KAAK,QAAQ,KAAK;;;AAIvD,MAAM,0BAA0B,KAAK;CACnC,YAAY;CACZ,QAAQ;CACT,CAAC;AAEF,MAAM,oBAAoB,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,SAAS,EAAE,EAAE,EAAE;AAEhF,IAAa,wBAAb,cAA2C,oBAA2C;CACpF,UAA4B;CAC5B,SAA2B,CAAC,WAAW;CACvC,cAAgC,CAAC,yBAAyB;CAC1D,OAAyB;CACzB,eAA0E;CAC1E,iBAA0B,QAAuC;EAC/D,OAAO,4BAA4B,OAAO;;CAE5C,QACE,QAC+D;EAC/D,MAAM,SAAS,gBAAgB,OAAO,OAAO;EAC7C,MAAM,uBAAwB,OAA6C;EAC3E,IAAI,OAAO,yBAAyB,YAAY,yBAAyB,OAAO,YAC9E,MAAM,aACJ,+BACA,wCAAwC,OAAO,WAAW,uDAAuD,qBAAqB,6HACtI;GACE,SAAS;GACT,sBAAsB,OAAO;GAC7B;GACD,CACF;EAEH,aAAa,IAAI,sBAA+B,MAAM,OAAO;;;AAIjE,MAAa,wBAAwB,IAAI,uBAAuB;;;;;;;;AAShE,SAAgB,kBACd,QACsE;CACtE,IAAI,CAAC,oBAAoB,OAAO,EAC9B,MAAM,IAAI,MACR,OAAO,WAAW,aACd,+DACA,oFACL;CAEH,MAAM,SAAmB,OAAuC;CAChE,IAAI,WAAW,QAAQ,OAAO,WAAW,UACvC,MAAM,IAAI,MAAM,yEAAyE;CAE3F,MAAM,SAAgC;EAAE,YAAY,OAAO;EAAY;EAAQ;CAC/E,OAAO,QACJ,SACC,IAAI,sBAAkC,uBAAuB,OAAO,EACtE,sBAAsB,SACtB,QACA,yBACD;;AAWH,MAAa,mBAAkD,CAAC,sBAAsB"}

package/dist/codecs.d.mts

@@ -1,4 +1,4 @@
-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-VX9T28RG.mjs";
+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-BRSKEodM.mjs";
 import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
 
 //#region src/core/registry.d.ts

package/dist/codecs.mjs

@@ -1,3 +1,3 @@
-import { n as ARKTYPE_JSON_NATIVE_TYPE, r as arktypeJsonColumn, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-DluUG3EZ.mjs";
-import { t as arktypeJsonCodecRegistry } from "./registry-CfU1C3-F.mjs";
+import { n as ARKTYPE_JSON_NATIVE_TYPE, r as arktypeJsonColumn, t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BjUHsoD5.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-CkZprj2g.mjs";
 export { ARKTYPE_JSON_CODEC_ID, ARKTYPE_JSON_NATIVE_TYPE, arktypeJsonCodecRegistry, arktypeJsonColumn };

package/dist/column-types.d.mts

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

package/dist/column-types.mjs

@@ -1,2 +1,2 @@
-import { r as arktypeJsonColumn } from "./arktype-json-codec-DluUG3EZ.mjs";
+import { r as arktypeJsonColumn } from "./arktype-json-codec-BjUHsoD5.mjs";
 export { arktypeJsonColumn as arktypeJson };

package/dist/control.mjs

@@ -1,5 +1,5 @@
-import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-DluUG3EZ.mjs";
-import { t as arktypeJsonPackMeta } from "./pack-meta-TjNpp3sc.mjs";
+import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BjUHsoD5.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-DA3cXkds.mjs";
 //#region src/exports/control.ts
 const arktypeJsonControlPlaneHooks = { expandNativeType: ({ nativeType }) => nativeType };
 const arktypeJsonExtensionDescriptor = {

package/dist/{pack-meta-TjNpp3sc.mjs → pack-meta-DA3cXkds.mjs}

@@ -1,5 +1,5 @@
-import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-DluUG3EZ.mjs";
-import { t as arktypeJsonCodecRegistry } from "./registry-CfU1C3-F.mjs";
+import { t as ARKTYPE_JSON_CODEC_ID } from "./arktype-json-codec-BjUHsoD5.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-CkZprj2g.mjs";
 /**
 * 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.
 */
@@ -30,4 +30,4 @@ const arktypeJsonPackMeta = {
 //#endregion
 export { arktypeJsonPackMeta as t };
 
-//# sourceMappingURL=pack-meta-TjNpp3sc.mjs.map
+//# sourceMappingURL=pack-meta-DA3cXkds.mjs.map

package/dist/{pack-meta-TjNpp3sc.mjs.map → pack-meta-DA3cXkds.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"pack-meta-TjNpp3sc.mjs","names":[],"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":";;;;;AA0CA,MAAa,sBAET;CA/BF,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;CAQC"}
+{"version":3,"file":"pack-meta-DA3cXkds.mjs","names":[],"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":";;;;;AA0CA,MAAa,sBAET;CA/BF,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;CAQC"}

package/dist/pack.mjs

@@ -1,2 +1,2 @@
-import { t as arktypeJsonPackMeta } from "./pack-meta-TjNpp3sc.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-DA3cXkds.mjs";
 export { arktypeJsonPackMeta, arktypeJsonPackMeta as default };

package/dist/{registry-CfU1C3-F.mjs → registry-CkZprj2g.mjs}

@@ -1,4 +1,4 @@
-import { i as codecDescriptors } from "./arktype-json-codec-DluUG3EZ.mjs";
+import { i as codecDescriptors } from "./arktype-json-codec-BjUHsoD5.mjs";
 import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
 //#region src/core/registry.ts
 /**
@@ -10,4 +10,4 @@ const arktypeJsonCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
 //#endregion
 export { arktypeJsonCodecRegistry as t };
 
-//# sourceMappingURL=registry-CfU1C3-F.mjs.map
+//# sourceMappingURL=registry-CkZprj2g.mjs.map

package/dist/{registry-CfU1C3-F.mjs.map → registry-CkZprj2g.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"registry-CfU1C3-F.mjs","names":[],"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,MAAa,2BACX,6BAA6B,iBAAiB"}
+{"version":3,"file":"registry-CkZprj2g.mjs","names":[],"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,MAAa,2BACX,6BAA6B,iBAAiB"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { t as arktypeJsonCodecRegistry } from "./registry-CfU1C3-F.mjs";
-import { t as arktypeJsonPackMeta } from "./pack-meta-TjNpp3sc.mjs";
+import { t as arktypeJsonCodecRegistry } from "./registry-CkZprj2g.mjs";
+import { t as arktypeJsonPackMeta } from "./pack-meta-DA3cXkds.mjs";
 //#region src/exports/runtime.ts
 const arktypeJsonRuntimeDescriptor = {
 	kind: "extension",
@@ -7,6 +7,7 @@ const arktypeJsonRuntimeDescriptor = {
 	version: arktypeJsonPackMeta.version,
 	familyId: "sql",
 	targetId: "postgres",
+	types: { codecTypes: { codecDescriptors: Array.from(arktypeJsonCodecRegistry.values()) } },
 	codecs: () => Array.from(arktypeJsonCodecRegistry.values()),
 	create() {
 		return {

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":[],"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,MAAa,+BAA0E;CACrF,MAAM;CACN,IAAI,oBAAoB;CACxB,SAAS,oBAAoB;CAC7B,UAAU;CACV,UAAU;CACV,cAAc,MAAM,KAAK,yBAAyB,QAAQ,CAAC;CAC3D,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ"}
+{"version":3,"file":"runtime.mjs","names":[],"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  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(arktypeJsonCodecRegistry.values()),\n    },\n  },\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,MAAa,+BAA0E;CACrF,MAAM;CACN,IAAI,oBAAoB;CACxB,SAAS,oBAAoB;CAC7B,UAAU;CACV,UAAU;CACV,OAAO,EACL,YAAY,EACV,kBAAkB,MAAM,KAAK,yBAAyB,QAAQ,CAAC,EAChE,EACF;CACD,cAAc,MAAM,KAAK,yBAAyB,QAAQ,CAAC;CAC3D,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ"}

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/extension-arktype-json",
-  "version": "0.6.0-dev.4",
+  "version": "0.6.0-dev.6",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "arktype": "^2.1.29",
-    "@prisma-next/contract-authoring": "0.6.0-dev.4",
-    "@prisma-next/family-sql": "0.6.0-dev.4",
-    "@prisma-next/contract": "0.6.0-dev.4",
-    "@prisma-next/sql-runtime": "0.6.0-dev.4",
-    "@prisma-next/framework-components": "0.6.0-dev.4",
-    "@prisma-next/sql-relational-core": "0.6.0-dev.4"
+    "arktype": "~2.1.29",
+    "@prisma-next/contract": "0.6.0-dev.6",
+    "@prisma-next/family-sql": "0.6.0-dev.6",
+    "@prisma-next/contract-authoring": "0.6.0-dev.6",
+    "@prisma-next/sql-runtime": "0.6.0-dev.6",
+    "@prisma-next/framework-components": "0.6.0-dev.6",
+    "@prisma-next/sql-relational-core": "0.6.0-dev.6"
   },
   "devDependencies": {
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5",
+    "@prisma-next/sql-contract": "0.6.0-dev.6",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/sql-contract": "0.6.0-dev.4",
-    "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",

package/src/core/arktype-json-codec.ts

@@ -22,7 +22,7 @@ import {
   type ColumnSpec,
   column,
 } from '@prisma-next/framework-components/codec';
-import { runtimeError } from '@prisma-next/framework-components/runtime';
+import { isRuntimeError, runtimeError } from '@prisma-next/framework-components/runtime';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { ArkErrors, ark, type Type, type } from 'arktype';
 
@@ -68,21 +68,63 @@ function validateSchema<TInferred>(schema: ArktypeSchemaLike, value: unknown): T
   return result as TInferred;
 }
 
-function serializeToJsonSafe<TInferred>(
-  schema: ArktypeSchemaLike,
-  value: TInferred,
-): { wire: string; json: JsonValue } {
+function serializeWire<TInferred>(value: TInferred): string {
   const wire: string | undefined = JSON.stringify(value);
   if (typeof wire !== 'string') {
-    throw runtimeError(
-      'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',
+    throw new Error(
       `arktype-json value is not representable as JSON (codecId: ${ARKTYPE_JSON_CODEC_ID})`,
-      { codecId: ARKTYPE_JSON_CODEC_ID },
     );
   }
-  const json = JSON.parse(wire) as JsonValue;
-  validateSchema(schema, json);
-  return { wire, json };
+  return wire;
+}
+
+function serializeJson<TInferred>(value: TInferred): JsonValue {
+  // The stringify → parse round-trip both validates JSON-representability
+  // (matching `serializeWire`) and produces a deep-cloned `JsonValue` that
+  // strips class prototypes / `toJSON` side effects, so callers reading
+  // the in-memory `JsonValue` see exactly the shape that would round-trip
+  // through the database.
+  return JSON.parse(serializeWire(value)) as JsonValue;
+}
+
+function parseJsonText(wire: string): JsonValue | undefined {
+  try {
+    return JSON.parse(wire) as JsonValue;
+  } catch {
+    return undefined;
+  }
+}
+
+function decodeWireValue<TInferred>(
+  schema: ArktypeSchemaLike,
+  wire: string | JsonValue,
+): TInferred {
+  if (typeof wire !== 'string') return validateSchema<TInferred>(schema, wire);
+
+  // Try the wire as the literal value first. Under `pg` + `jsonb` (the
+  // documented native type), wire arrives already-parsed: a JSON object
+  // surfaces as a JS object, a JSON string surfaces as a JS string. For
+  // string columns that means the wire IS the user's value — including
+  // strings whose literal characters happen to start and end with `"`.
+  // A `"…"`-shape unwrap heuristic would silently truncate them (the
+  // 7-char `"hello"` would decode to the 5-char `hello`).
+  //
+  // Fall back to JSON.parse only when schema validation rejects the raw
+  // wire: that path covers object/array shapes received as raw JSON
+  // text (legacy `json` text-OID adapters, or any code path that hands
+  // us un-pre-parsed JSON).
+  try {
+    return validateSchema<TInferred>(schema, wire);
+  } catch (error) {
+    if (!isRuntimeError(error) || error.code !== 'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED') {
+      throw error;
+    }
+    const parsed = parseJsonText(wire);
+    if (parsed === undefined) {
+      throw error;
+    }
+    return validateSchema<TInferred>(schema, parsed);
+  }
 }
 
 function rehydrateSchema(jsonIr: object): ArktypeSchemaLike {
@@ -117,7 +159,7 @@ function renderArktypeJsonOutputType(params: ArktypeJsonTypeParams): string {
 export class ArktypeJsonCodecClass<TInferred> extends CodecImpl<
   typeof ARKTYPE_JSON_CODEC_ID,
   readonly ['equality'],
-  string,
+  string | JsonValue,
   TInferred
 > {
   constructor(
@@ -128,15 +170,15 @@ export class ArktypeJsonCodecClass<TInferred> extends CodecImpl<
   }
 
   async encode(value: TInferred, _ctx: CodecCallContext): Promise<string> {
-    return serializeToJsonSafe(this.schema, value).wire;
+    return serializeWire(value);
   }
 
-  async decode(wire: string, _ctx: CodecCallContext): Promise<TInferred> {
-    return validateSchema<TInferred>(this.schema, JSON.parse(wire));
+  async decode(wire: string | JsonValue, _ctx: CodecCallContext): Promise<TInferred> {
+    return decodeWireValue<TInferred>(this.schema, wire);
   }
 
   encodeJson(value: TInferred): JsonValue {
-    return serializeToJsonSafe(this.schema, value).json;
+    return serializeJson(value);
   }
 
   decodeJson(json: JsonValue): TInferred {
@@ -149,10 +191,13 @@ const arktypeJsonParamsSchema = type({
   jsonIr: 'object',
 }) satisfies StandardSchemaV1<ArktypeJsonTypeParams>;
 
+const ARKTYPE_JSON_META = { db: { sql: { postgres: { nativeType: 'jsonb' } } } } as const;
+
 export class ArktypeJsonDescriptor extends CodecDescriptorImpl<ArktypeJsonTypeParams> {
   override readonly codecId = ARKTYPE_JSON_CODEC_ID;
   override readonly traits = ['equality'] as const;
   override readonly targetTypes = [ARKTYPE_JSON_NATIVE_TYPE] as const;
+  override readonly meta = ARKTYPE_JSON_META;
   override readonly paramsSchema: StandardSchemaV1<ArktypeJsonTypeParams> = arktypeJsonParamsSchema;
   override renderOutputType(params: ArktypeJsonTypeParams): string {
     return renderArktypeJsonOutputType(params);
@@ -161,14 +206,18 @@ export class ArktypeJsonDescriptor extends CodecDescriptorImpl<ArktypeJsonTypePa
     params: ArktypeJsonTypeParams,
   ): (ctx: CodecInstanceContext) => ArktypeJsonCodecClass<unknown> {
     const schema = rehydrateSchema(params.jsonIr);
-    /* c8 ignore start — defensive parity check; not exercised by typical contracts */
     const rehydratedExpression = (schema as { readonly expression?: unknown }).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.`,
+      throw runtimeError(
+        'RUNTIME.TYPE_PARAMS_INVALID',
+        `arktype-json: typeParams.expression (${params.expression}) does not match the rehydrated schema's expression (${rehydratedExpression}). The contract was likely emitted against a different arktype version or hand-edited; re-run \`pnpm emit\` to regenerate.`,
+        {
+          codecId: ARKTYPE_JSON_CODEC_ID,
+          serializedExpression: params.expression,
+          rehydratedExpression,
+        },
       );
     }
-    /* c8 ignore stop */
     return () => new ArktypeJsonCodecClass<unknown>(this, schema);
   }
 }

package/src/exports/runtime.ts

@@ -16,6 +16,11 @@ export const arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgr
   version: arktypeJsonPackMeta.version,
   familyId: 'sql' as const,
   targetId: 'postgres' as const,
+  types: {
+    codecTypes: {
+      codecDescriptors: Array.from(arktypeJsonCodecRegistry.values()),
+    },
+  },
   codecs: () => Array.from(arktypeJsonCodecRegistry.values()),
   create() {
     return {

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

@@ -1 +0,0 @@
-{"version":3,"file":"arktype-json-codec-DluUG3EZ.mjs","names":[],"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;CACvE,IAAI,OAAO,UAAU,YAAY,OAAO;CAExC,OAAO,OADa,MAA4C,eACnC;;AAG/B,SAAS,eAA0B,QAA2B,OAA2B;CACvF,MAAM,SAAS,OAAO,MAAM;CAC5B,IAAI,kBAAkB,WACpB,MAAM,aACJ,yCACA,mDAAmD,OAAO,WAC1D;EAAE,SAAS;EAAuB,QAAQ,OAAO;EAAS,CAC3D;CAEH,OAAO;;AAGT,SAAS,oBACP,QACA,OACmC;CACnC,MAAM,OAA2B,KAAK,UAAU,MAAM;CACtD,IAAI,OAAO,SAAS,UAClB,MAAM,aACJ,yCACA,6DAA6D,sBAAsB,IACnF,EAAE,SAAS,uBAAuB,CACnC;CAEH,MAAM,OAAO,KAAK,MAAM,KAAK;CAC7B,eAAe,QAAQ,KAAK;CAC5B,OAAO;EAAE;EAAM;EAAM;;AAGvB,SAAS,gBAAgB,QAAmC;CAC1D,IAAI;CACJ,IAAI;EACF,aAAa,IAAI,OAAO,OAAO;UACxB,OAAO;EACd,MAAM;GACJ;;GAEA,wDAAwD,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;GAC9G;IAAE,SAAS;IAAuB;IAAQ;GAC3C;;;CAGH,IAAI,CAAC,oBAAoB,WAAW,EAClC,MAAM,aACJ,yCACA,wGAAwG,sBAAsB,IAC9H;EAAE,SAAS;EAAuB;EAAQ,CAC3C;;CAGH,OAAO;;AAGT,SAAS,4BAA4B,QAAuC;CAC1E,MAAM,aAAa,OAAO,WAAW,MAAM;CAC3C,OAAO,WAAW,SAAS,IAAI,aAAa;;AAG9C,IAAa,wBAAb,cAAsD,UAKpD;CAGmB;CAFnB,YACE,YACA,QACA;EACA,MAAM,WAAW;EAFA,KAAA,SAAA;;CAKnB,MAAM,OAAO,OAAkB,MAAyC;EACtE,OAAO,oBAAoB,KAAK,QAAQ,MAAM,CAAC;;CAGjD,MAAM,OAAO,MAAc,MAA4C;EACrE,OAAO,eAA0B,KAAK,QAAQ,KAAK,MAAM,KAAK,CAAC;;CAGjE,WAAW,OAA6B;EACtC,OAAO,oBAAoB,KAAK,QAAQ,MAAM,CAAC;;CAGjD,WAAW,MAA4B;EACrC,OAAO,eAA0B,KAAK,QAAQ,KAAK;;;AAIvD,MAAM,0BAA0B,KAAK;CACnC,YAAY;CACZ,QAAQ;CACT,CAAC;AAEF,IAAa,wBAAb,cAA2C,oBAA2C;CACpF,UAA4B;CAC5B,SAA2B,CAAC,WAAW;CACvC,cAAgC,CAAC,yBAAyB;CAC1D,eAA0E;CAC1E,iBAA0B,QAAuC;EAC/D,OAAO,4BAA4B,OAAO;;CAE5C,QACE,QAC+D;EAC/D,MAAM,SAAS,gBAAgB,OAAO,OAAO;;EAE7C,MAAM,uBAAwB,OAA6C;EAC3E,IAAI,OAAO,yBAAyB,YAAY,yBAAyB,OAAO,YAC9E,QAAQ,KACN,yCAAyC,OAAO,WAAW,iDAAiD,qBAAqB,+DAClI;;EAGH,aAAa,IAAI,sBAA+B,MAAM,OAAO;;;AAIjE,MAAa,wBAAwB,IAAI,uBAAuB;;;;;;;;AAShE,SAAgB,kBACd,QACsE;CACtE,IAAI,CAAC,oBAAoB,OAAO,EAC9B,MAAM,IAAI,MACR,OAAO,WAAW,aACd,+DACA,oFACL;CAEH,MAAM,SAAmB,OAAuC;CAChE,IAAI,WAAW,QAAQ,OAAO,WAAW,UACvC,MAAM,IAAI,MAAM,yEAAyE;CAE3F,MAAM,SAAgC;EAAE,YAAY,OAAO;EAAY;EAAQ;CAC/E,OAAO,QACJ,SACC,IAAI,sBAAkC,uBAAuB,OAAO,EACtE,sBAAsB,SACtB,QACA,yBACD;;AAWH,MAAa,mBAAkD,CAAC,sBAAsB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"arktype-json-codec-VX9T28RG.d.mts","names":[],"sources":["../src/core/arktype-json-codec.ts"],"mappings":";;;;;;AAqCA;AAAA,cARa,qBAAA;;cAGA,wBAAA;;AAcX;;KATU,qBAAA;EAWe;;AAoE3B;EApE2B,SAPhB,UAAA;EA2EuB;;;EAAA,SAvEvB,MAAA;AAAA;AAAA,KAGN,iBAAA,KAAsB,KAAA;EAAA,SAChB,UAAA;AAAA;AAAA,cAmEE,qBAAA,oBAAyC,SAAA,QAC7C,qBAAA,iCAGP,SAAA;EAAA,iBAImB,MAAA;cADjB,UAAA,EAAY,qBAAA,EACK,MAAA,EAAQ,iBAAA;EAKrB,MAAA,CAAO,KAAA,EAAO,SAAA,EAAW,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAIlD,MAAA,CAAO,IAAA,UAAc,IAAA,EAAM,gBAAA,GAAmB,OAAA,CAAQ,SAAA;EAI5D,UAAA,CAAW,KAAA,EAAO,SAAA,GAAY,SAAA;EAI9B,UAAA,CAAW,IAAA,EAAM,SAAA,GAAY,SAAA;AAAA;AAAA,cAUlB,qBAAA,SAA8B,mBAAA,CAAoB,qBAAA;EAAA,SAC3C,OAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA,EAAc,gBAAA,CAAiB,qBAAA;EACxC,gBAAA,CAAiB,MAAA,EAAQ,qBAAA;EAGzB,OAAA,CACP,MAAA,EAAQ,qBAAA,IACN,GAAA,EAAK,oBAAA,KAAyB,qBAAA;AAAA;;;;;;;;iBAuBpB,iBAAA,WAA4B,IAAA,UAAA,CAC1C,MAAA,EAAQ,CAAA,GACP,UAAA,CAAW,qBAAA,CAAsB,CAAA,YAAa,qBAAA;;;;KA4BrC,gBAAA,cAA8B,qBAAA,CAAsB,SAAA"}