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

package/src/exports/runtime.ts

@@ -1,28 +1,14 @@
 /**
  * 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.
+ * 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.
  *
- * Lives at the runtime-plane entrypoint so `src/core/**` stays free of
- * runtime-plane imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).
+ * Lives at the runtime-plane entrypoint so `src/core/**` stays free of runtime-plane imports (per `.cursor/rules/multi-plane-entrypoints.mdc`).
  */
 
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
-import { arktypeJsonCodec } from '../core/arktype-json-codec';
 import { arktypeJsonPackMeta } from '../core/pack-meta';
-
-function createArktypeJsonCodecRegistry() {
-  // arktype-json ships only the parameterized descriptor; the legacy
-  // `codecs:` slot has nothing to register.
-  return createCodecRegistry();
-}
+import { arktypeJsonCodecRegistry } from '../core/registry';
 
 export const arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   kind: 'extension' as const,
@@ -30,8 +16,7 @@ export const arktypeJsonRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgr
   version: arktypeJsonPackMeta.version,
   familyId: 'sql' as const,
   targetId: 'postgres' as const,
-  codecs: createArktypeJsonCodecRegistry,
-  parameterizedCodecs: () => [arktypeJsonCodec],
+  codecs: () => Array.from(arktypeJsonCodecRegistry.values()),
   create() {
     return {
       familyId: 'sql' as const,

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

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

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

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

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

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

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

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

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

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

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

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