@confect/core 9.2.2 → 10.0.0-next.0

package/dist/Ref.js

@@ -1,10 +1,10 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { makeFunctionReference } from "convex/server";
 import { ConvexError } from "convex/values";
 import * as Effect from "effect/Effect";
 import * as Match from "effect/Match";
-import * as Option from "effect/Option";
 
 //#region src/Ref.ts
 var Ref_exports = /* @__PURE__ */ __exportAll({
@@ -40,12 +40,12 @@ const getFunctionReference = (ref) => {
 	return functionReference;
 };
 const hasErrorSchema = (ref) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance), Match.tag("Convex", () => false), Match.exhaustive);
-const encodeArgs = (ref, args) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.encode(confectFunctionProvenance.args)(args)), Match.tag("Convex", () => Effect.succeed(args)), Match.exhaustive);
-const decodeReturns = (ref, returns) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decode(confectFunctionProvenance.returns)(returns)), Match.tag("Convex", () => Effect.succeed(returns)), Match.exhaustive);
+const encodeArgs = (ref, args) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.encodeEffect(confectFunctionProvenance.args)(args)), Match.tag("Convex", () => Effect.succeed(args)), Match.exhaustive);
+const decodeReturns = (ref, returns) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decodeUnknownEffect(confectFunctionProvenance.returns)(returns)), Match.tag("Convex", () => Effect.succeed(returns)), Match.exhaustive);
 const encodeArgsSync = (ref, args) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.encodeSync(confectFunctionProvenance.args)(args)), Match.tag("Convex", () => args), Match.exhaustive);
-const decodeArgsSync = (ref, encodedArgs) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decodeSync(confectFunctionProvenance.args)(encodedArgs)), Match.tag("Convex", () => encodedArgs), Match.exhaustive);
+const decodeArgsSync = (ref, encodedArgs) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decodeUnknownSync(confectFunctionProvenance.args)(encodedArgs)), Match.tag("Convex", () => encodedArgs), Match.exhaustive);
 const encodeReturnsSync = (ref, returns) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.encodeSync(confectFunctionProvenance.returns)(returns)), Match.tag("Convex", () => returns), Match.exhaustive);
-const decodeReturnsSync = (ref, encodedReturns) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decodeSync(confectFunctionProvenance.returns)(encodedReturns)), Match.tag("Convex", () => encodedReturns), Match.exhaustive);
+const decodeReturnsSync = (ref, encodedReturns) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.decodeUnknownSync(confectFunctionProvenance.returns)(encodedReturns)), Match.tag("Convex", () => encodedReturns), Match.exhaustive);
 const ConvexErrorIdentifier = Symbol.for("ConvexError");
 const isConvexError = (error) => error instanceof ConvexError || typeof error === "object" && error !== null && ConvexErrorIdentifier in error;
 /**
@@ -71,13 +71,13 @@ const decodeErrorOrElse = (ref, mapUnknownError) => (error) => {
 * into, and the caller is responsible for deciding what to do (typically:
 * surface the original value as a defect).
 */
-const decodeError = (ref, encodedError) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Effect.map(Schema.decode(confectFunctionProvenance.error)(encodedError), Option.some) : Effect.succeed(Option.none())), Match.tag("Convex", () => Effect.succeed(Option.none())), Match.exhaustive);
+const decodeError = (ref, encodedError) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Effect.map(Schema.decodeUnknownEffect(confectFunctionProvenance.error)(encodedError), Option.some) : Effect.succeed(Option.none())), Match.tag("Convex", () => Effect.succeed(Option.none())), Match.exhaustive);
 /**
 * Synchronous counterpart to `decodeError`. Throws on schema decode failure;
 * returns `None` when the ref doesn't declare a typed error.
 */
-const decodeErrorSync = (ref, encodedError) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Option.some(Schema.decodeSync(confectFunctionProvenance.error)(encodedError)) : Option.none()), Match.tag("Convex", () => Option.none()), Match.exhaustive);
-const maybeDecodeErrorSync = (ref, error) => isConvexError(error) ? Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Schema.decodeSync(confectFunctionProvenance.error)(error.data) : error), Match.tag("Convex", () => error), Match.exhaustive) : error;
+const decodeErrorSync = (ref, encodedError) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Option.some(Schema.decodeUnknownSync(confectFunctionProvenance.error)(encodedError)) : Option.none()), Match.tag("Convex", () => Option.none()), Match.exhaustive);
+const maybeDecodeErrorSync = (ref, error) => isConvexError(error) ? Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => "error" in confectFunctionProvenance ? Schema.decodeUnknownSync(confectFunctionProvenance.error)(error.data) : error), Match.tag("Convex", () => error), Match.exhaustive) : error;
 /**
 * Encode args via the ref's args schema, invoke `call`, decode returns via the
 * ref's returns schema, and translate any thrown `ConvexError` into the ref's
@@ -101,8 +101,8 @@ const runWithCodec = (ref, args, call, mapUnknownError) => Effect.gen(function*
 		}
 	});
 	return yield* Match.value(functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Effect.gen(function* () {
-		const encodedReturns = yield* invoke(yield* Schema.encode(confectFunctionProvenance.args)(args));
-		return yield* Schema.decode(confectFunctionProvenance.returns)(encodedReturns);
+		const encodedReturns = yield* invoke(yield* Schema.encodeEffect(confectFunctionProvenance.args)(args));
+		return yield* Schema.decodeUnknownEffect(confectFunctionProvenance.returns)(encodedReturns);
 	})), Match.tag("Convex", () => invoke(args)), Match.exhaustive);
 });
 

package/dist/Ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"Ref.js","names":[],"sources":["../src/Ref.ts"],"sourcesContent":["import type {\n  FunctionReference as ConvexFunctionReference,\n  FunctionVisibility,\n} from \"convex/server\";\nimport { makeFunctionReference } from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport type { ParseResult } from \"effect\";\nimport * as Effect from \"effect/Effect\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Schema from \"effect/Schema\";\nimport type * as FunctionSpec from \"./FunctionSpec\";\nimport type * as RuntimeAndFunctionType from \"./RuntimeAndFunctionType\";\n\nexport interface Ref<\n  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,\n  _FunctionVisibility extends FunctionVisibility,\n  _Args,\n  _Returns,\n  _Error = never,\n> {\n  readonly _RuntimeAndFunctionType?: _RuntimeAndFunctionType;\n  readonly _FunctionVisibility?: _FunctionVisibility;\n  readonly _Args?: _Args;\n  readonly _Returns?: _Returns;\n  readonly _Error?: _Error;\n  /** @internal */\n  readonly functionSpec: FunctionSpec.AnyWithProps;\n  /** @internal */\n  readonly functionNamespace: string;\n}\n\nexport interface Any extends Ref<any, any, any, any, any> {}\n\nexport interface AnyInternal extends Ref<any, \"internal\", any, any, any> {}\n\nexport interface AnyPublic extends Ref<any, \"public\", any, any, any> {}\n\nexport interface AnyQuery extends Ref<\n  RuntimeAndFunctionType.AnyQuery,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyMutation extends Ref<\n  RuntimeAndFunctionType.AnyMutation,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyAction extends Ref<\n  RuntimeAndFunctionType.AnyAction,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicQuery extends Ref<\n  RuntimeAndFunctionType.AnyQuery,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicMutation extends Ref<\n  RuntimeAndFunctionType.AnyMutation,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicAction extends Ref<\n  RuntimeAndFunctionType.AnyAction,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport type GetRuntimeAndFunctionType<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType_\n    : never;\n\nexport type GetRuntime<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType.GetRuntime<RuntimeAndFunctionType_>\n    : never;\n\nexport type GetFunctionType<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_>\n    : never;\n\nexport type GetFunctionVisibility<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer FunctionVisibility_,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? FunctionVisibility_\n    : never;\n\nexport type Args<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer Args_,\n    infer _Returns,\n    infer _Error\n  >\n    ? Args_\n    : never;\n\nexport type OptionalArgs<Ref_ extends Any> = keyof Args<Ref_> extends never\n  ? [args?: Args<Ref_>]\n  : [args: Args<Ref_>];\n\nexport type Returns<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer Returns_,\n    infer _Error\n  >\n    ? Returns_\n    : never;\n\nexport type Error<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer Error_\n  >\n    ? Error_\n    : never;\n\nexport type FunctionReference<Ref_ extends Any> = ConvexFunctionReference<\n  GetFunctionType<Ref_>,\n  GetFunctionVisibility<Ref_>\n>;\n\nexport type FromFunctionSpec<FunctionSpec_ extends FunctionSpec.AnyWithProps> =\n  Ref<\n    FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,\n    FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n    FunctionSpec.Args<FunctionSpec_>,\n    FunctionSpec.Returns<FunctionSpec_>,\n    FunctionSpec.Error<FunctionSpec_>\n  >;\n\nexport const make = <FunctionSpec_ extends FunctionSpec.AnyWithProps>(\n  /**\n   * The namespace portion of a Convex function name, i.e. the part before the\n   * colon. For example, for `myGroupDir/myGroupMod:myFunc` this would be\n   * `myGroupDir/myGroupMod`.\n   */\n  functionNamespace: string,\n  functionSpec: FunctionSpec_,\n): FromFunctionSpec<FunctionSpec_> => ({ functionSpec, functionNamespace });\n\nexport const getConvexFunctionName = (ref: Any): string =>\n  `${ref.functionNamespace}:${ref.functionSpec.name}`;\n\nconst functionReferenceCache = new Map<string, FunctionReference<Any>>();\n\nexport const getFunctionReference = <Ref_ extends Any>(\n  ref: Ref_,\n): FunctionReference<Ref_> => {\n  const functionName = getConvexFunctionName(ref);\n\n  const cached = functionReferenceCache.get(functionName);\n  if (cached !== undefined) {\n    return cached as FunctionReference<Ref_>;\n  }\n\n  const functionReference = makeFunctionReference(functionName);\n  functionReferenceCache.set(functionName, functionReference);\n\n  return functionReference as FunctionReference<Ref_>;\n};\n\nexport const hasErrorSchema = (ref: Any): boolean =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\n      \"Confect\",\n      (confectFunctionProvenance) => \"error\" in confectFunctionProvenance,\n    ),\n    Match.tag(\"Convex\", () => false),\n    Match.exhaustive,\n  );\n\nexport const encodeArgs = <Ref_ extends Any>(\n  ref: Ref_,\n  args: Args<Ref_>,\n): Effect.Effect<unknown, ParseResult.ParseError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encode(confectFunctionProvenance.args)(args),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(args)),\n    Match.exhaustive,\n  );\n\nexport const decodeReturns = <Ref_ extends Any>(\n  ref: Ref_,\n  returns: unknown,\n): Effect.Effect<Returns<Ref_>, ParseResult.ParseError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decode(confectFunctionProvenance.returns)(returns),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(returns)),\n    Match.exhaustive,\n  );\n\nexport const encodeArgsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  args: Args<Ref_>,\n): unknown =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encodeSync(confectFunctionProvenance.args)(args),\n    ),\n    Match.tag(\"Convex\", () => args),\n    Match.exhaustive,\n  );\n\nexport const decodeArgsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedArgs: unknown,\n): Args<Ref_> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decodeSync(confectFunctionProvenance.args)(encodedArgs),\n    ),\n    Match.tag(\"Convex\", () => encodedArgs),\n    Match.exhaustive,\n  ) as Args<Ref_>;\n\nexport const encodeReturnsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  returns: Returns<Ref_>,\n): unknown =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encodeSync(confectFunctionProvenance.returns)(returns),\n    ),\n    Match.tag(\"Convex\", () => returns),\n    Match.exhaustive,\n  );\n\nexport const decodeReturnsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedReturns: unknown,\n): Returns<Ref_> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decodeSync(confectFunctionProvenance.returns)(encodedReturns),\n    ),\n    Match.tag(\"Convex\", () => encodedReturns),\n    Match.exhaustive,\n  ) as Returns<Ref_>;\n\nconst ConvexErrorIdentifier = Symbol.for(\"ConvexError\");\n\nexport const isConvexError = (error: unknown): error is ConvexError<Value> =>\n  error instanceof ConvexError ||\n  (typeof error === \"object\" &&\n    error !== null &&\n    ConvexErrorIdentifier in error);\n\n/**\n * Build a callback-style handler that decodes the ref's typed error from a\n * caught `ConvexError`, or else forwards the value to `mapUnknownError`. The\n * fallback is also invoked when the input *is* a `ConvexError` but the ref\n * doesn't declare a typed-error schema—by definition such a value falls\n * outside the ref's error contract. Useful when adapting non-Effect APIs (e.g.\n * emitter callbacks for streamed subscriptions) to the same error semantics\n * that `runWithCodec` provides.\n */\nexport const decodeErrorOrElse =\n  <Ref_ extends Any, E>(ref: Ref_, mapUnknownError: (error: unknown) => E) =>\n  (error: unknown): Error<Ref_> | E => {\n    if (isConvexError(error)) {\n      const decoded = decodeErrorSync(ref, error.data);\n      if (Option.isSome(decoded)) {\n        return decoded.value;\n      }\n    }\n    return mapUnknownError(error);\n  };\n\n/**\n * Decode `encodedError` against the ref's error schema. Returns `None` if the\n * ref doesn't declare a typed error (Confect ref without an `error` schema, or\n * a Convex-provenance ref)—by definition there's nothing to decode the value\n * into, and the caller is responsible for deciding what to do (typically:\n * surface the original value as a defect).\n */\nexport const decodeError = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedError: unknown,\n): Effect.Effect<Option.Option<Error<Ref_>>, ParseResult.ParseError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      \"error\" in confectFunctionProvenance\n        ? Effect.map(\n            Schema.decode(confectFunctionProvenance.error)(encodedError),\n            Option.some,\n          )\n        : Effect.succeed(Option.none<Error<Ref_>>()),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(Option.none<Error<Ref_>>())),\n    Match.exhaustive,\n  );\n\n/**\n * Synchronous counterpart to `decodeError`. Throws on schema decode failure;\n * returns `None` when the ref doesn't declare a typed error.\n */\nexport const decodeErrorSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedError: unknown,\n): Option.Option<Error<Ref_>> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      \"error\" in confectFunctionProvenance\n        ? Option.some(\n            Schema.decodeSync(confectFunctionProvenance.error)(\n              encodedError,\n            ) as Error<Ref_>,\n          )\n        : Option.none<Error<Ref_>>(),\n    ),\n    Match.tag(\"Convex\", () => Option.none<Error<Ref_>>()),\n    Match.exhaustive,\n  );\n\nexport const maybeDecodeErrorSync = <Ref_ extends Any>(\n  ref: Ref_,\n  error: unknown,\n): unknown =>\n  isConvexError(error)\n    ? Match.value(ref.functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionProvenance) =>\n          \"error\" in confectFunctionProvenance\n            ? Schema.decodeSync(confectFunctionProvenance.error)(error.data)\n            : error,\n        ),\n        Match.tag(\"Convex\", () => error),\n        Match.exhaustive,\n      )\n    : error;\n\n/**\n * Encode args via the ref's args schema, invoke `call`, decode returns via the\n * ref's returns schema, and translate any thrown `ConvexError` into the ref's\n * typed error. Anything else the Promise rejects with—network failures,\n * server-side runtime errors, validation failures, etc.—is passed to\n * `mapUnknownError` to be turned into a typed `E`, or surfaced as a defect when\n * no handler is provided.\n */\nexport const runWithCodec = <Ref_ extends Any, E = never>(\n  ref: Ref_,\n  args: Args<Ref_>,\n  call: (\n    functionReference: FunctionReference<Ref_>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>,\n  mapUnknownError?: (error: unknown) => E,\n): Effect.Effect<Returns<Ref_>, E | Error<Ref_> | ParseResult.ParseError> =>\n  Effect.gen(function* () {\n    const functionReference = getFunctionReference(ref);\n    const functionProvenance = ref.functionSpec.functionProvenance;\n    const invoke = (\n      encodedArgs: unknown,\n    ): Effect.Effect<unknown, Error<Ref_> | E> =>\n      Effect.tryPromise({\n        try: () => Promise.resolve(call(functionReference, encodedArgs)),\n        catch: (error): Error<Ref_> | E => {\n          if (isConvexError(error)) {\n            const decoded = decodeErrorSync(ref, error.data);\n            if (Option.isSome(decoded)) {\n              return decoded.value;\n            }\n          }\n          if (mapUnknownError !== undefined) {\n            return mapUnknownError(error);\n          }\n          throw error;\n        },\n      });\n    return yield* Match.value(functionProvenance).pipe(\n      Match.tag(\"Confect\", (confectFunctionProvenance) =>\n        Effect.gen(function* () {\n          const encodedArgs = yield* Schema.encode(\n            confectFunctionProvenance.args,\n          )(args);\n          const encodedReturns = yield* invoke(encodedArgs);\n          return yield* Schema.decode(confectFunctionProvenance.returns)(\n            encodedReturns,\n          );\n        }),\n      ),\n      Match.tag(\"Convex\", () => invoke(args)),\n      Match.exhaustive,\n    );\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAsLA,MAAa,QAMX,mBACA,kBACqC;CAAE;CAAc;CAAmB;AAE1E,MAAa,yBAAyB,QACpC,GAAG,IAAI,kBAAkB,GAAG,IAAI,aAAa;AAE/C,MAAM,yCAAyB,IAAI,KAAqC;AAExE,MAAa,wBACX,QAC4B;CAC5B,MAAM,eAAe,sBAAsB,IAAI;CAE/C,MAAM,SAAS,uBAAuB,IAAI,aAAa;AACvD,KAAI,WAAW,OACb,QAAO;CAGT,MAAM,oBAAoB,sBAAsB,aAAa;AAC7D,wBAAuB,IAAI,cAAc,kBAAkB;AAE3D,QAAO;;AAGT,MAAa,kBAAkB,QAC7B,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IACJ,YACC,8BAA8B,WAAW,0BAC3C,EACD,MAAM,IAAI,gBAAgB,MAAM,EAChC,MAAM,WACP;AAEH,MAAa,cACX,KACA,SAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,OAAO,0BAA0B,KAAK,CAAC,KAAK,CACpD,EACD,MAAM,IAAI,gBAAgB,OAAO,QAAQ,KAAK,CAAC,EAC/C,MAAM,WACP;AAEH,MAAa,iBACX,KACA,YAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,OAAO,0BAA0B,QAAQ,CAAC,QAAQ,CAC1D,EACD,MAAM,IAAI,gBAAgB,OAAO,QAAQ,QAAQ,CAAC,EAClD,MAAM,WACP;AAEH,MAAa,kBACX,KACA,SAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,WAAW,0BAA0B,KAAK,CAAC,KAAK,CACxD,EACD,MAAM,IAAI,gBAAgB,KAAK,EAC/B,MAAM,WACP;AAEH,MAAa,kBACX,KACA,gBAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,WAAW,0BAA0B,KAAK,CAAC,YAAY,CAC/D,EACD,MAAM,IAAI,gBAAgB,YAAY,EACtC,MAAM,WACP;AAEH,MAAa,qBACX,KACA,YAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,WAAW,0BAA0B,QAAQ,CAAC,QAAQ,CAC9D,EACD,MAAM,IAAI,gBAAgB,QAAQ,EAClC,MAAM,WACP;AAEH,MAAa,qBACX,KACA,mBAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,OAAO,WAAW,0BAA0B,QAAQ,CAAC,eAAe,CACrE,EACD,MAAM,IAAI,gBAAgB,eAAe,EACzC,MAAM,WACP;AAEH,MAAM,wBAAwB,OAAO,IAAI,cAAc;AAEvD,MAAa,iBAAiB,UAC5B,iBAAiB,eAChB,OAAO,UAAU,YAChB,UAAU,QACV,yBAAyB;;;;;;;;;;AAW7B,MAAa,qBACW,KAAW,qBAChC,UAAoC;AACnC,KAAI,cAAc,MAAM,EAAE;EACxB,MAAM,UAAU,gBAAgB,KAAK,MAAM,KAAK;AAChD,MAAI,OAAO,OAAO,QAAQ,CACxB,QAAO,QAAQ;;AAGnB,QAAO,gBAAgB,MAAM;;;;;;;;;AAUjC,MAAa,eACX,KACA,iBAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,WAAW,4BACP,OAAO,IACL,OAAO,OAAO,0BAA0B,MAAM,CAAC,aAAa,EAC5D,OAAO,KACR,GACD,OAAO,QAAQ,OAAO,MAAmB,CAAC,CAC/C,EACD,MAAM,IAAI,gBAAgB,OAAO,QAAQ,OAAO,MAAmB,CAAC,CAAC,EACrE,MAAM,WACP;;;;;AAMH,MAAa,mBACX,KACA,iBAEA,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,WAAW,4BACP,OAAO,KACL,OAAO,WAAW,0BAA0B,MAAM,CAChD,aACD,CACF,GACD,OAAO,MAAmB,CAC/B,EACD,MAAM,IAAI,gBAAgB,OAAO,MAAmB,CAAC,EACrD,MAAM,WACP;AAEH,MAAa,wBACX,KACA,UAEA,cAAc,MAAM,GAChB,MAAM,MAAM,IAAI,aAAa,mBAAmB,CAAC,KAC/C,MAAM,IAAI,YAAY,8BACpB,WAAW,4BACP,OAAO,WAAW,0BAA0B,MAAM,CAAC,MAAM,KAAK,GAC9D,MACL,EACD,MAAM,IAAI,gBAAgB,MAAM,EAChC,MAAM,WACP,GACD;;;;;;;;;AAUN,MAAa,gBACX,KACA,MACA,MAIA,oBAEA,OAAO,IAAI,aAAa;CACtB,MAAM,oBAAoB,qBAAqB,IAAI;CACnD,MAAM,qBAAqB,IAAI,aAAa;CAC5C,MAAM,UACJ,gBAEA,OAAO,WAAW;EAChB,WAAW,QAAQ,QAAQ,KAAK,mBAAmB,YAAY,CAAC;EAChE,QAAQ,UAA2B;AACjC,OAAI,cAAc,MAAM,EAAE;IACxB,MAAM,UAAU,gBAAgB,KAAK,MAAM,KAAK;AAChD,QAAI,OAAO,OAAO,QAAQ,CACxB,QAAO,QAAQ;;AAGnB,OAAI,oBAAoB,OACtB,QAAO,gBAAgB,MAAM;AAE/B,SAAM;;EAET,CAAC;AACJ,QAAO,OAAO,MAAM,MAAM,mBAAmB,CAAC,KAC5C,MAAM,IAAI,YAAY,8BACpB,OAAO,IAAI,aAAa;EAItB,MAAM,iBAAiB,OAAO,OAHV,OAAO,OAAO,OAChC,0BAA0B,KAC3B,CAAC,KAAK,CAC0C;AACjD,SAAO,OAAO,OAAO,OAAO,0BAA0B,QAAQ,CAC5D,eACD;GACD,CACH,EACD,MAAM,IAAI,gBAAgB,OAAO,KAAK,CAAC,EACvC,MAAM,WACP;EACD"}
+{"version":3,"file":"Ref.js","names":[],"sources":["../src/Ref.ts"],"sourcesContent":["import type {\n  FunctionReference as ConvexFunctionReference,\n  FunctionVisibility,\n} from \"convex/server\";\nimport { makeFunctionReference } from \"convex/server\";\nimport type { Value } from \"convex/values\";\nimport { ConvexError } from \"convex/values\";\nimport * as Effect from \"effect/Effect\";\nimport * as Match from \"effect/Match\";\nimport * as Option from \"effect/Option\";\nimport * as Schema from \"effect/Schema\";\nimport type * as FunctionSpec from \"./FunctionSpec\";\nimport type * as RuntimeAndFunctionType from \"./RuntimeAndFunctionType\";\n\nexport interface Ref<\n  _RuntimeAndFunctionType extends RuntimeAndFunctionType.RuntimeAndFunctionType,\n  _FunctionVisibility extends FunctionVisibility,\n  _Args,\n  _Returns,\n  _Error = never,\n> {\n  readonly _RuntimeAndFunctionType?: _RuntimeAndFunctionType;\n  readonly _FunctionVisibility?: _FunctionVisibility;\n  readonly _Args?: _Args;\n  readonly _Returns?: _Returns;\n  readonly _Error?: _Error;\n  /** @internal */\n  readonly functionSpec: FunctionSpec.AnyWithProps;\n  /** @internal */\n  readonly functionNamespace: string;\n}\n\nexport interface Any extends Ref<any, any, any, any, any> {}\n\nexport interface AnyInternal extends Ref<any, \"internal\", any, any, any> {}\n\nexport interface AnyPublic extends Ref<any, \"public\", any, any, any> {}\n\nexport interface AnyQuery extends Ref<\n  RuntimeAndFunctionType.AnyQuery,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyMutation extends Ref<\n  RuntimeAndFunctionType.AnyMutation,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyAction extends Ref<\n  RuntimeAndFunctionType.AnyAction,\n  FunctionVisibility,\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicQuery extends Ref<\n  RuntimeAndFunctionType.AnyQuery,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicMutation extends Ref<\n  RuntimeAndFunctionType.AnyMutation,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport interface AnyPublicAction extends Ref<\n  RuntimeAndFunctionType.AnyAction,\n  \"public\",\n  any,\n  any,\n  any\n> {}\n\nexport type GetRuntimeAndFunctionType<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType_\n    : never;\n\nexport type GetRuntime<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType.GetRuntime<RuntimeAndFunctionType_>\n    : never;\n\nexport type GetFunctionType<Ref_> =\n  Ref_ extends Ref<\n    infer RuntimeAndFunctionType_,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? RuntimeAndFunctionType.GetFunctionType<RuntimeAndFunctionType_>\n    : never;\n\nexport type GetFunctionVisibility<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer FunctionVisibility_,\n    infer _Args,\n    infer _Returns,\n    infer _Error\n  >\n    ? FunctionVisibility_\n    : never;\n\nexport type Args<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer Args_,\n    infer _Returns,\n    infer _Error\n  >\n    ? Args_\n    : never;\n\nexport type OptionalArgs<Ref_ extends Any> = keyof Args<Ref_> extends never\n  ? [args?: Args<Ref_>]\n  : [args: Args<Ref_>];\n\nexport type Returns<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer Returns_,\n    infer _Error\n  >\n    ? Returns_\n    : never;\n\nexport type Error<Ref_> =\n  Ref_ extends Ref<\n    infer _RuntimeAndFunctionType,\n    infer _FunctionVisibility,\n    infer _Args,\n    infer _Returns,\n    infer Error_\n  >\n    ? Error_\n    : never;\n\nexport type FunctionReference<Ref_ extends Any> = ConvexFunctionReference<\n  GetFunctionType<Ref_>,\n  GetFunctionVisibility<Ref_>\n>;\n\nexport type FromFunctionSpec<FunctionSpec_ extends FunctionSpec.AnyWithProps> =\n  Ref<\n    FunctionSpec.GetRuntimeAndFunctionType<FunctionSpec_>,\n    FunctionSpec.GetFunctionVisibility<FunctionSpec_>,\n    FunctionSpec.Args<FunctionSpec_>,\n    FunctionSpec.Returns<FunctionSpec_>,\n    FunctionSpec.Error<FunctionSpec_>\n  >;\n\nexport const make = <FunctionSpec_ extends FunctionSpec.AnyWithProps>(\n  /**\n   * The namespace portion of a Convex function name, i.e. the part before the\n   * colon. For example, for `myGroupDir/myGroupMod:myFunc` this would be\n   * `myGroupDir/myGroupMod`.\n   */\n  functionNamespace: string,\n  functionSpec: FunctionSpec_,\n): FromFunctionSpec<FunctionSpec_> => ({ functionSpec, functionNamespace });\n\nexport const getConvexFunctionName = (ref: Any): string =>\n  `${ref.functionNamespace}:${ref.functionSpec.name}`;\n\nconst functionReferenceCache = new Map<string, FunctionReference<Any>>();\n\nexport const getFunctionReference = <Ref_ extends Any>(\n  ref: Ref_,\n): FunctionReference<Ref_> => {\n  const functionName = getConvexFunctionName(ref);\n\n  const cached = functionReferenceCache.get(functionName);\n  if (cached !== undefined) {\n    return cached as FunctionReference<Ref_>;\n  }\n\n  const functionReference = makeFunctionReference(functionName);\n  functionReferenceCache.set(functionName, functionReference);\n\n  return functionReference as FunctionReference<Ref_>;\n};\n\nexport const hasErrorSchema = (ref: Any): boolean =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\n      \"Confect\",\n      (confectFunctionProvenance) => \"error\" in confectFunctionProvenance,\n    ),\n    Match.tag(\"Convex\", () => false),\n    Match.exhaustive,\n  );\n\nexport const encodeArgs = <Ref_ extends Any>(\n  ref: Ref_,\n  args: Args<Ref_>,\n): Effect.Effect<unknown, Schema.SchemaError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encodeEffect(confectFunctionProvenance.args)(args),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(args)),\n    Match.exhaustive,\n  );\n\nexport const decodeReturns = <Ref_ extends Any>(\n  ref: Ref_,\n  returns: unknown,\n): Effect.Effect<Returns<Ref_>, Schema.SchemaError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decodeUnknownEffect(confectFunctionProvenance.returns)(returns),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(returns)),\n    Match.exhaustive,\n  );\n\nexport const encodeArgsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  args: Args<Ref_>,\n): unknown =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encodeSync(confectFunctionProvenance.args)(args),\n    ),\n    Match.tag(\"Convex\", () => args),\n    Match.exhaustive,\n  );\n\nexport const decodeArgsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedArgs: unknown,\n): Args<Ref_> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decodeUnknownSync(confectFunctionProvenance.args)(encodedArgs),\n    ),\n    Match.tag(\"Convex\", () => encodedArgs),\n    Match.exhaustive,\n  ) as Args<Ref_>;\n\nexport const encodeReturnsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  returns: Returns<Ref_>,\n): unknown =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.encodeSync(confectFunctionProvenance.returns)(returns),\n    ),\n    Match.tag(\"Convex\", () => returns),\n    Match.exhaustive,\n  );\n\nexport const decodeReturnsSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedReturns: unknown,\n): Returns<Ref_> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      Schema.decodeUnknownSync(confectFunctionProvenance.returns)(\n        encodedReturns,\n      ),\n    ),\n    Match.tag(\"Convex\", () => encodedReturns),\n    Match.exhaustive,\n  ) as Returns<Ref_>;\n\nconst ConvexErrorIdentifier = Symbol.for(\"ConvexError\");\n\nexport const isConvexError = (error: unknown): error is ConvexError<Value> =>\n  error instanceof ConvexError ||\n  (typeof error === \"object\" &&\n    error !== null &&\n    ConvexErrorIdentifier in error);\n\n/**\n * Build a callback-style handler that decodes the ref's typed error from a\n * caught `ConvexError`, or else forwards the value to `mapUnknownError`. The\n * fallback is also invoked when the input *is* a `ConvexError` but the ref\n * doesn't declare a typed-error schema—by definition such a value falls\n * outside the ref's error contract. Useful when adapting non-Effect APIs (e.g.\n * emitter callbacks for streamed subscriptions) to the same error semantics\n * that `runWithCodec` provides.\n */\nexport const decodeErrorOrElse =\n  <Ref_ extends Any, E>(ref: Ref_, mapUnknownError: (error: unknown) => E) =>\n  (error: unknown): Error<Ref_> | E => {\n    if (isConvexError(error)) {\n      const decoded = decodeErrorSync(ref, error.data);\n      if (Option.isSome(decoded)) {\n        return decoded.value;\n      }\n    }\n    return mapUnknownError(error);\n  };\n\n/**\n * Decode `encodedError` against the ref's error schema. Returns `None` if the\n * ref doesn't declare a typed error (Confect ref without an `error` schema, or\n * a Convex-provenance ref)—by definition there's nothing to decode the value\n * into, and the caller is responsible for deciding what to do (typically:\n * surface the original value as a defect).\n */\nexport const decodeError = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedError: unknown,\n): Effect.Effect<Option.Option<Error<Ref_>>, Schema.SchemaError> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      \"error\" in confectFunctionProvenance\n        ? Effect.map(\n            Schema.decodeUnknownEffect(confectFunctionProvenance.error)(\n              encodedError,\n            ),\n            Option.some,\n          )\n        : Effect.succeed(Option.none<Error<Ref_>>()),\n    ),\n    Match.tag(\"Convex\", () => Effect.succeed(Option.none<Error<Ref_>>())),\n    Match.exhaustive,\n  );\n\n/**\n * Synchronous counterpart to `decodeError`. Throws on schema decode failure;\n * returns `None` when the ref doesn't declare a typed error.\n */\nexport const decodeErrorSync = <Ref_ extends Any>(\n  ref: Ref_,\n  encodedError: unknown,\n): Option.Option<Error<Ref_>> =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\"Confect\", (confectFunctionProvenance) =>\n      \"error\" in confectFunctionProvenance\n        ? Option.some(\n            Schema.decodeUnknownSync(confectFunctionProvenance.error)(\n              encodedError,\n            ) as Error<Ref_>,\n          )\n        : Option.none<Error<Ref_>>(),\n    ),\n    Match.tag(\"Convex\", () => Option.none<Error<Ref_>>()),\n    Match.exhaustive,\n  );\n\nexport const maybeDecodeErrorSync = <Ref_ extends Any>(\n  ref: Ref_,\n  error: unknown,\n): unknown =>\n  isConvexError(error)\n    ? Match.value(ref.functionSpec.functionProvenance).pipe(\n        Match.tag(\"Confect\", (confectFunctionProvenance) =>\n          \"error\" in confectFunctionProvenance\n            ? Schema.decodeUnknownSync(confectFunctionProvenance.error)(\n                error.data,\n              )\n            : error,\n        ),\n        Match.tag(\"Convex\", () => error),\n        Match.exhaustive,\n      )\n    : error;\n\n/**\n * Encode args via the ref's args schema, invoke `call`, decode returns via the\n * ref's returns schema, and translate any thrown `ConvexError` into the ref's\n * typed error. Anything else the Promise rejects with—network failures,\n * server-side runtime errors, validation failures, etc.—is passed to\n * `mapUnknownError` to be turned into a typed `E`, or surfaced as a defect when\n * no handler is provided.\n */\nexport const runWithCodec = <Ref_ extends Any, E = never>(\n  ref: Ref_,\n  args: Args<Ref_>,\n  call: (\n    functionReference: FunctionReference<Ref_>,\n    encodedArgs: unknown,\n  ) => PromiseLike<unknown>,\n  mapUnknownError?: (error: unknown) => E,\n): Effect.Effect<Returns<Ref_>, E | Error<Ref_> | Schema.SchemaError> =>\n  Effect.gen(function* () {\n    const functionReference = getFunctionReference(ref);\n    const functionProvenance = ref.functionSpec.functionProvenance;\n    const invoke = (\n      encodedArgs: unknown,\n    ): Effect.Effect<unknown, Error<Ref_> | E> =>\n      Effect.tryPromise({\n        try: () => Promise.resolve(call(functionReference, encodedArgs)),\n        catch: (error): Error<Ref_> | E => {\n          if (isConvexError(error)) {\n            const decoded = decodeErrorSync(ref, error.data);\n            if (Option.isSome(decoded)) {\n              return decoded.value;\n            }\n          }\n          if (mapUnknownError !== undefined) {\n            return mapUnknownError(error);\n          }\n          throw error;\n        },\n      });\n    return yield* Match.value(functionProvenance).pipe(\n      Match.tag(\"Confect\", (confectFunctionProvenance) =>\n        Effect.gen(function* () {\n          const encodedArgs = yield* Schema.encodeEffect(\n            confectFunctionProvenance.args,\n          )(args);\n          const encodedReturns = yield* invoke(encodedArgs);\n          return yield* Schema.decodeUnknownEffect(\n            confectFunctionProvenance.returns,\n          )(encodedReturns);\n        }),\n      ),\n      Match.tag(\"Convex\", () => invoke(args)),\n      Match.exhaustive,\n    );\n  });\n"],"mappings":"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"}

package/dist/Refs.js

@@ -1,7 +1,7 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { getConvexFunctionName, make as make$1 } from "./Ref.js";
-import * as Record from "effect/Record";
 import * as Option from "effect/Option";
+import * as Record from "effect/Record";
 import { pipe } from "effect/Function";
 
 //#region src/Refs.ts

package/dist/Registry.d.ts

@@ -11,7 +11,6 @@ import * as Ref from "effect/Ref";
 export interface RegistryItems {
     readonly [key: string]: unknown | RegistryItems;
 }
-declare const Registry_base: Context.ReferenceClass<Registry, "@confect/core/Registry", Ref.Ref<RegistryItems>>;
 /**
  * Effect `Context.Reference` keyed by `@confect/core/Registry`. Lives in
  * `@confect/core` so `@confect/server` (which writes to it from
@@ -21,7 +20,5 @@ declare const Registry_base: Context.ReferenceClass<Registry, "@confect/core/Reg
  * Effect's global default-value cache to align two separately-defined tags
  * by string key.
  */
-export declare class Registry extends Registry_base {
-}
-export {};
+export declare const Registry: Context.Reference<Ref.Ref<RegistryItems>>;
 //# sourceMappingURL=Registry.d.ts.map

package/dist/Registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,GAAG,MAAM,YAAY,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,CAAC;CACjD;;AAED;;;;;;;;GAQG;AACH,qBAAa,QAAS,SAAQ,aAK7B;CAAG"}
+{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,GAAG,MAAM,YAAY,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,aAAa,CAAC;CACjD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,2CAKpB,CAAC"}

package/dist/Registry.js

@@ -13,7 +13,7 @@ var Registry_exports = /* @__PURE__ */ __exportAll({ Registry: () => Registry })
 * Effect's global default-value cache to align two separately-defined tags
 * by string key.
 */
-var Registry = class extends Context.Reference()("@confect/core/Registry", { defaultValue: () => Ref.unsafeMake({}) }) {};
+const Registry = Context.Reference("@confect/core/Registry", { defaultValue: () => Ref.makeUnsafe({}) });
 
 //#endregion
 export { Registry, Registry_exports };

package/dist/Registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import * as Context from \"effect/Context\";\nimport * as Ref from \"effect/Ref\";\n\n/**\n * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the\n * per-function items written by each `FunctionImpl`'s layer initializer. The\n * leaf type is intentionally `unknown` here so `@confect/core` does not need\n * to know about `@confect/server`'s `RegistryItem` shape; producers and\n * consumers (the server runtime and the CLI's `implValidation`) narrow as\n * needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown | RegistryItems;\n}\n\n/**\n * Effect `Context.Reference` keyed by `@confect/core/Registry`. Lives in\n * `@confect/core` so `@confect/server` (which writes to it from\n * `FunctionImpl` initializers and reads it from `RegisteredFunctions`) and\n * `@confect/cli` (which inspects it during impl validation) can share the\n * exact same `Ref` instance by importing the same tag — without relying on\n * Effect's global default-value cache to align two separately-defined tags\n * by string key.\n */\nexport class Registry extends Context.Reference<Registry>()(\n  \"@confect/core/Registry\",\n  {\n    defaultValue: () => Ref.unsafeMake<RegistryItems>({}),\n  },\n) {}\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,IAAa,WAAb,cAA8B,QAAQ,WAAqB,CACzD,0BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF,CAAC"}
+{"version":3,"file":"Registry.js","names":[],"sources":["../src/Registry.ts"],"sourcesContent":["import * as Context from \"effect/Context\";\nimport * as Ref from \"effect/Ref\";\n\n/**\n * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the\n * per-function items written by each `FunctionImpl`'s layer initializer. The\n * leaf type is intentionally `unknown` here so `@confect/core` does not need\n * to know about `@confect/server`'s `RegistryItem` shape; producers and\n * consumers (the server runtime and the CLI's `implValidation`) narrow as\n * needed.\n */\nexport interface RegistryItems {\n  readonly [key: string]: unknown | RegistryItems;\n}\n\n/**\n * Effect `Context.Reference` keyed by `@confect/core/Registry`. Lives in\n * `@confect/core` so `@confect/server` (which writes to it from\n * `FunctionImpl` initializers and reads it from `RegisteredFunctions`) and\n * `@confect/cli` (which inspects it during impl validation) can share the\n * exact same `Ref` instance by importing the same tag — without relying on\n * Effect's global default-value cache to align two separately-defined tags\n * by string key.\n */\nexport const Registry = Context.Reference<Ref.Ref<RegistryItems>>(\n  \"@confect/core/Registry\",\n  {\n    defaultValue: () => Ref.makeUnsafe<RegistryItems>({}),\n  },\n);\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,MAAa,WAAW,QAAQ,UAC9B,0BACA,EACE,oBAAoB,IAAI,WAA0B,EAAE,CAAC,EACtD,CACF"}

package/dist/SystemFields.d.ts

@@ -1,22 +1,63 @@
-import type { Expand, IdField, SystemFields as NonIdSystemFields } from "convex/server";
+import type { IdField, SystemFields as NonIdSystemFields } from "convex/server";
 import * as Schema from "effect/Schema";
-import * as GenericId from "./GenericId";
-type SystemFieldsSchema<TableName extends string> = Schema.Struct<{
-    _id: Schema.Schema<GenericId.GenericId<TableName>, GenericId.GenericId<TableName>, never>;
-    _creationTime: typeof Schema.Number;
+import * as Struct from "effect/Struct";
+/**
+ * Produces a schema for Convex system fields. In Confect, system fields include `_id`.
+ */
+export declare const SystemFields: <TableName extends string>(tableName: TableName) => Schema.Struct<{
+    readonly _id: Schema.Codec<import("convex/values").GenericId<TableName>, import("convex/values").GenericId<TableName>, never, never>;
+    readonly _creationTime: Schema.Number;
 }>;
 /**
- * Produces a schema for Convex system fields.
+ * The field map added to a table schema, derived from {@link SystemFields} so it
+ * stays in lockstep with the runtime schema.
  */
-export declare const SystemFields: <TableName extends string>(tableName: TableName) => SystemFieldsSchema<TableName>;
+type SystemFieldsFor<TableName extends string> = ReturnType<typeof SystemFields<TableName>>["fields"];
 /**
  * Extend a table schema with Convex system fields.
+ *
+ * A plain `Struct` gains the fields via `Schema.fieldsAssign` and a `Union`
+ * has them distributed across its members, preserving the schema's
+ * `Struct`/`Union` structure. Any other object-shaped schema — one built with
+ * `Schema.decodeTo`/`Schema.encodeKeys`, a branded struct, a suspended schema
+ * — is extended at the AST level: every object node in its encoding chain
+ * gains the system fields, and each transformation is wrapped so the fields
+ * bypass the user-defined getters. Schemas that do not resolve to an object
+ * shape at every step (such as `Schema.Class`, whose decoded values are class
+ * instances) are rejected with a descriptive error.
+ *
+ * Note that struct-level checks on an extended schema observe the value with
+ * the system fields attached, and encoding an extended schema emits the system
+ * fields alongside the table fields.
+ */
+export declare const extendWithSystemFields: <TableName extends string, TableSchema extends Schema.Codec<any, any>>(tableName: TableName, schema: TableSchema) => ExtendWithSystemFields<TableName, TableSchema>;
+/**
+ * Applies the system fields to a single struct, mirroring `Schema.fieldsAssign`.
+ * Any other (already-extended or opaque) schema falls back to a `Codec` carrying
+ * the system-field document shape.
  */
-export declare const extendWithSystemFields: <TableName extends string, TableSchema extends Schema.Schema.AnyNoContext>(tableName: TableName, schema: TableSchema) => ExtendWithSystemFields<TableName, TableSchema>;
+type ApplySystemFields<TableName extends string, S> = S extends Schema.Struct<infer Fields extends Schema.Struct.Fields> ? Schema.Struct<Struct.Simplify<Struct.Assign<Fields, SystemFieldsFor<TableName>>>> : S extends Schema.Codec<infer Type, infer Encoded> ? Schema.Codec<WithSystemFields<TableName, Type>, WithSystemFields<TableName, Encoded>> : never;
 /**
  * Extend a table schema with Convex system fields at the type level.
+ *
+ * This mirrors the runtime {@link extendWithSystemFields}: a `Struct` gains the
+ * system fields directly (matching `Schema.fieldsAssign`), and a `Union` has
+ * them distributed across its members (matching
+ * `union.mapMembers(Tuple.map(Schema.fieldsAssign(...)))`). The `Struct`/`Union`
+ * structure is preserved rather than collapsed to a bare `Codec`; any other
+ * schema falls back to a `Codec` carrying the system-field document shape,
+ * matching the runtime's AST-level extension.
+ */
+export type ExtendWithSystemFields<TableName extends string, TableSchema extends Schema.Top> = TableSchema extends Schema.Union<infer Members extends ReadonlyArray<Schema.Top>> ? Schema.Union<Struct.Simplify<Readonly<{
+    [K in keyof Members]: ExtendWithSystemFields<TableName, Members[K]>;
+}>>> : ApplySystemFields<TableName, TableSchema>;
+/**
+ * The decoded/encoded document shape: a table's fields plus Convex's system
+ * fields. Deliberately a bare intersection (no `Expand`/`Simplify`) — flattening
+ * it with a homomorphic mapped type collapses to `{ [x: string]: any }` when
+ * `Document` is still an unresolved generic, which breaks structural
+ * comparability in the database reader/writer plumbing.
  */
-export type ExtendWithSystemFields<TableName extends string, TableSchema extends Schema.Schema.AnyNoContext> = Schema.extend<SystemFieldsSchema<TableName>, TableSchema>;
-export type WithSystemFields<TableName extends string, Document> = Expand<Readonly<IdField<TableName>> & Readonly<NonIdSystemFields> & Document>;
+export type WithSystemFields<TableName extends string, Document> = Document extends unknown ? IdField<TableName> & NonIdSystemFields & Document : never;
 export {};
 //# sourceMappingURL=SystemFields.d.ts.map

package/dist/SystemFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemFields.d.ts","sourceRoot":"","sources":["../src/SystemFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,OAAO,EACP,YAAY,IAAI,iBAAiB,EAClC,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,KAAK,kBAAkB,CAAC,SAAS,SAAS,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC;IAChE,GAAG,EAAE,MAAM,CAAC,MAAM,CAChB,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,EAC9B,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,EAC9B,KAAK,CACN,CAAC;IACF,aAAa,EAAE,OAAO,MAAM,CAAC,MAAM,CAAC;CACrC,CAAC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,MAAM,EACnD,WAAW,SAAS,KACnB,kBAAkB,CAAC,SAAS,CAI3B,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,SAAS,MAAM,EACxB,WAAW,SAAS,MAAM,CAAC,MAAM,CAAC,YAAY,EAE9C,WAAW,SAAS,EACpB,QAAQ,WAAW,KAClB,sBAAsB,CAAC,SAAS,EAAE,WAAW,CACA,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAChC,SAAS,SAAS,MAAM,EACxB,WAAW,SAAS,MAAM,CAAC,MAAM,CAAC,YAAY,IAC5C,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,CAAC;AAE9D,MAAM,MAAM,gBAAgB,CAAC,SAAS,SAAS,MAAM,EAAE,QAAQ,IAAI,MAAM,CACvE,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,GAAG,QAAQ,CAAC,iBAAiB,CAAC,GAAG,QAAQ,CACtE,CAAC"}
+{"version":3,"file":"SystemFields.d.ts","sourceRoot":"","sources":["../src/SystemFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,IAAI,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAOhF,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,SAAS,MAAM,EAAE,WAAW,SAAS;;;EAIvE,CAAC;AAEL;;;GAGG;AACH,KAAK,eAAe,CAAC,SAAS,SAAS,MAAM,IAAI,UAAU,CACzD,OAAO,YAAY,CAAC,SAAS,CAAC,CAC/B,CAAC,QAAQ,CAAC,CAAC;AA4HZ;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,SAAS,MAAM,EACxB,WAAW,SAAS,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAE1C,WAAW,SAAS,EACpB,QAAQ,WAAW,KAClB,sBAAsB,CAAC,SAAS,EAAE,WAAW,CA6C/C,CAAC;AAEF;;;;GAIG;AACH,KAAK,iBAAiB,CAAC,SAAS,SAAS,MAAM,EAAE,CAAC,IAChD,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,MAAM,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,GAC9D,MAAM,CAAC,MAAM,CACX,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,CACnE,GACD,CAAC,SAAS,MAAM,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,MAAM,OAAO,CAAC,GAC/C,MAAM,CAAC,KAAK,CACV,gBAAgB,CAAC,SAAS,EAAE,IAAI,CAAC,EACjC,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CACrC,GACD,KAAK,CAAC;AAEd;;;;;;;;;;GAUG;AACH,MAAM,MAAM,sBAAsB,CAChC,SAAS,SAAS,MAAM,EACxB,WAAW,SAAS,MAAM,CAAC,GAAG,IAE9B,WAAW,SAAS,MAAM,CAAC,KAAK,CAC9B,MAAM,OAAO,SAAS,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,CAChD,GACG,MAAM,CAAC,KAAK,CACV,MAAM,CAAC,QAAQ,CACb,QAAQ,CAAC;KACN,CAAC,IAAI,MAAM,OAAO,GAAG,sBAAsB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CACpE,CAAC,CACH,CACF,GACD,iBAAiB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,CAC1B,SAAS,SAAS,MAAM,EACxB,QAAQ,IACN,QAAQ,SAAS,OAAO,GACxB,OAAO,CAAC,SAAS,CAAC,GAAG,iBAAiB,GAAG,QAAQ,GACjD,KAAK,CAAC"}

package/dist/SystemFields.js

@@ -1,6 +1,16 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
 import { GenericId } from "./GenericId.js";
+import * as Predicate from "effect/Predicate";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import * as Record from "effect/Record";
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as Array from "effect/Array";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import * as Struct from "effect/Struct";
 
 //#region src/SystemFields.ts
 var SystemFields_exports = /* @__PURE__ */ __exportAll({
@@ -8,16 +18,83 @@ var SystemFields_exports = /* @__PURE__ */ __exportAll({
 	extendWithSystemFields: () => extendWithSystemFields
 });
 /**
-* Produces a schema for Convex system fields.
+* Produces a schema for Convex system fields. In Confect, system fields include `_id`.
 */
 const SystemFields = (tableName) => Schema.Struct({
 	_id: GenericId(tableName),
 	_creationTime: Schema.Number
 });
 /**
+* The system field names, derived from {@link SystemFields} so they stay in
+* lockstep with the schema.
+*/
+const systemFieldNames = Record.keys(SystemFields("").fields);
+const isSystemFieldKey = (key) => Predicate.isString(key) && Array.contains(systemFieldNames, key);
+const splitSystemFields = (input) => {
+	const keys = Reflect.ownKeys(input);
+	const pick = (pickedKeys) => Record.fromEntries(Array.map(pickedKeys, (key) => [key, input[key]]));
+	return {
+		system: pick(Array.filter(keys, isSystemFieldKey)),
+		rest: pick(Array.filter(keys, Predicate.not(isSystemFieldKey)))
+	};
+};
+/**
+* Wraps a transformation getter so the system fields bypass it: they are split
+* off the input before the user-defined getter runs and merged back into its
+* output. Transformations construct fresh objects, so without this the system
+* fields would be dropped at every transformation step.
+*/
+const wrapGetter = (getter) => new SchemaGetter.Getter((input, options) => {
+	if (Option.isNone(input) || !Predicate.isObject(input.value)) return getter.run(input, options);
+	const { system, rest } = splitSystemFields(input.value);
+	return getter.run(Option.some(rest), options).pipe(Effect.map(Option.map((output) => Predicate.isObject(output) ? Struct.assign(output, system) : output)));
+});
+const wrapTransformation = (transformation) => {
+	if (!SchemaTransformation.isTransformation(transformation)) throw new Error("Cannot extend a table schema that uses decoding/encoding middleware with system fields");
+	return new SchemaTransformation.Transformation(wrapGetter(transformation.decode), wrapGetter(transformation.encode));
+};
+/**
+* Builds an AST walker that adds the given system-field property signatures to
+* every object node of a schema's AST — including each step of its encoding
+* chain — wrapping transformations so the fields survive them.
+*/
+const makeExtendAst = (systemPropertySignatures) => {
+	const extendEncoding = (encoding) => Array.map(encoding, (link) => new SchemaAST.Link(extendAst(link.to), wrapTransformation(link.transformation)));
+	const extendAst = (ast) => {
+		if (SchemaAST.isUnion(ast)) return new SchemaAST.Union(Array.map(ast.types, extendAst), ast.mode, ast.annotations, ast.checks, ast.encoding === void 0 ? void 0 : extendEncoding(ast.encoding), ast.context, ast.encodingChecks);
+		if (SchemaAST.isSuspend(ast)) return new SchemaAST.Suspend(() => extendAst(ast.thunk()), ast.annotations, void 0, ast.encoding === void 0 ? void 0 : extendEncoding(ast.encoding), ast.context);
+		if (SchemaAST.isObjects(ast)) return new SchemaAST.Objects(Array.appendAll(ast.propertySignatures, systemPropertySignatures), ast.indexSignatures, ast.annotations, ast.checks, ast.encoding === void 0 ? void 0 : extendEncoding(ast.encoding), ast.context, ast.encodingChecks);
+		throw new Error(ast._tag === "Declaration" ? "Cannot extend a `Declaration` schema (such as a `Schema.Class`) with system fields: its decoded values are constructed instances, which cannot gain extra fields. Use a plain `Schema.Struct`, or transform to one with `Schema.decodeTo`." : `Cannot extend a \`${ast._tag}\` schema node with system fields: a table schema must resolve to an object shape at every step of its encoding.`);
+	};
+	return extendAst;
+};
+/**
 * Extend a table schema with Convex system fields.
+*
+* A plain `Struct` gains the fields via `Schema.fieldsAssign` and a `Union`
+* has them distributed across its members, preserving the schema's
+* `Struct`/`Union` structure. Any other object-shaped schema — one built with
+* `Schema.decodeTo`/`Schema.encodeKeys`, a branded struct, a suspended schema
+* — is extended at the AST level: every object node in its encoding chain
+* gains the system fields, and each transformation is wrapped so the fields
+* bypass the user-defined getters. Schemas that do not resolve to an object
+* shape at every step (such as `Schema.Class`, whose decoded values are class
+* instances) are rejected with a descriptive error.
+*
+* Note that struct-level checks on an extended schema observe the value with
+* the system fields attached, and encoding an extended schema emits the system
+* fields alongside the table fields.
 */
-const extendWithSystemFields = (tableName, schema) => Schema.extend(SystemFields(tableName), schema);
+const extendWithSystemFields = (tableName, schema) => {
+	const system = SystemFields(tableName).fields;
+	const extendAst = makeExtendAst(pipe(system, Record.toEntries, Array.map(([name, field]) => new SchemaAST.PropertySignature(name, field.ast))));
+	const extend = (s) => {
+		if (s.ast.encoding === void 0 && SchemaAST.isUnion(s.ast) && Array.isArray(s.members)) return Schema.Union(Array.map(s.members, extend));
+		if (s.ast.encoding === void 0 && SchemaAST.isObjects(s.ast) && typeof s.mapFields === "function") return Schema.fieldsAssign(system)(s);
+		return Schema.make(extendAst(s.ast));
+	};
+	return extend(schema);
+};
 
 //#endregion
 export { SystemFields, SystemFields_exports, extendWithSystemFields };

package/dist/SystemFields.js.map

@@ -1 +1 @@
-{"version":3,"file":"SystemFields.js","names":["GenericId.GenericId"],"sources":["../src/SystemFields.ts"],"sourcesContent":["import type {\n  Expand,\n  IdField,\n  SystemFields as NonIdSystemFields,\n} from \"convex/server\";\nimport * as Schema from \"effect/Schema\";\nimport * as GenericId from \"./GenericId\";\n\ntype SystemFieldsSchema<TableName extends string> = Schema.Struct<{\n  _id: Schema.Schema<\n    GenericId.GenericId<TableName>,\n    GenericId.GenericId<TableName>,\n    never\n  >;\n  _creationTime: typeof Schema.Number;\n}>;\n\n/**\n * Produces a schema for Convex system fields.\n */\nexport const SystemFields = <TableName extends string>(\n  tableName: TableName,\n): SystemFieldsSchema<TableName> =>\n  Schema.Struct({\n    _id: GenericId.GenericId(tableName),\n    _creationTime: Schema.Number,\n  });\n\n/**\n * Extend a table schema with Convex system fields.\n */\nexport const extendWithSystemFields = <\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n>(\n  tableName: TableName,\n  schema: TableSchema,\n): ExtendWithSystemFields<TableName, TableSchema> =>\n  Schema.extend(SystemFields(tableName), schema);\n\n/**\n * Extend a table schema with Convex system fields at the type level.\n */\nexport type ExtendWithSystemFields<\n  TableName extends string,\n  TableSchema extends Schema.Schema.AnyNoContext,\n> = Schema.extend<SystemFieldsSchema<TableName>, TableSchema>;\n\nexport type WithSystemFields<TableName extends string, Document> = Expand<\n  Readonly<IdField<TableName>> & Readonly<NonIdSystemFields> & Document\n>;\n"],"mappings":";;;;;;;;;;;;AAoBA,MAAa,gBACX,cAEA,OAAO,OAAO;CACZ,KAAKA,UAAoB,UAAU;CACnC,eAAe,OAAO;CACvB,CAAC;;;;AAKJ,MAAa,0BAIX,WACA,WAEA,OAAO,OAAO,aAAa,UAAU,EAAE,OAAO"}
+{"version":3,"file":"SystemFields.js","names":["GenericId.GenericId"],"sources":["../src/SystemFields.ts"],"sourcesContent":["import type { IdField, SystemFields as NonIdSystemFields } from \"convex/server\";\nimport { pipe } from \"effect/Function\";\nimport * as Array from \"effect/Array\";\nimport * as Effect from \"effect/Effect\";\nimport * as Option from \"effect/Option\";\nimport * as Predicate from \"effect/Predicate\";\nimport * as Record from \"effect/Record\";\nimport * as Schema from \"effect/Schema\";\nimport * as SchemaAST from \"effect/SchemaAST\";\nimport * as SchemaGetter from \"effect/SchemaGetter\";\nimport * as SchemaTransformation from \"effect/SchemaTransformation\";\nimport * as Struct from \"effect/Struct\";\nimport * as GenericId from \"./GenericId\";\n\n/**\n * Produces a schema for Convex system fields. In Confect, system fields include `_id`.\n */\nexport const SystemFields = <TableName extends string>(tableName: TableName) =>\n  Schema.Struct({\n    _id: GenericId.GenericId(tableName),\n    _creationTime: Schema.Number,\n  });\n\n/**\n * The field map added to a table schema, derived from {@link SystemFields} so it\n * stays in lockstep with the runtime schema.\n */\ntype SystemFieldsFor<TableName extends string> = ReturnType<\n  typeof SystemFields<TableName>\n>[\"fields\"];\n\n/**\n * The system field names, derived from {@link SystemFields} so they stay in\n * lockstep with the schema.\n */\nconst systemFieldNames: ReadonlyArray<string> = Record.keys(\n  SystemFields(\"\").fields,\n);\n\nconst isSystemFieldKey = (key: string | symbol): key is string =>\n  Predicate.isString(key) && Array.contains(systemFieldNames, key);\n\nconst splitSystemFields = (input: { [key: PropertyKey]: unknown }) => {\n  const keys = Reflect.ownKeys(input);\n  const pick = (pickedKeys: ReadonlyArray<string | symbol>) =>\n    Record.fromEntries(\n      Array.map(pickedKeys, (key) => [key, input[key]] as const),\n    );\n  return {\n    system: pick(Array.filter(keys, isSystemFieldKey)),\n    rest: pick(Array.filter(keys, Predicate.not(isSystemFieldKey))),\n  };\n};\n\n/**\n * Wraps a transformation getter so the system fields bypass it: they are split\n * off the input before the user-defined getter runs and merged back into its\n * output. Transformations construct fresh objects, so without this the system\n * fields would be dropped at every transformation step.\n */\nconst wrapGetter = (\n  getter: SchemaGetter.Getter<any, any, any>,\n): SchemaGetter.Getter<any, any, any> =>\n  new SchemaGetter.Getter((input, options) => {\n    if (Option.isNone(input) || !Predicate.isObject(input.value)) {\n      return getter.run(input, options);\n    }\n    const { system, rest } = splitSystemFields(input.value);\n    return getter\n      .run(Option.some(rest), options)\n      .pipe(\n        Effect.map(\n          Option.map((output) =>\n            Predicate.isObject(output) ? Struct.assign(output, system) : output,\n          ),\n        ),\n      );\n  });\n\nconst wrapTransformation = (\n  transformation: SchemaAST.Link[\"transformation\"],\n): SchemaTransformation.Transformation<any, any, any, any> => {\n  if (!SchemaTransformation.isTransformation(transformation)) {\n    throw new Error(\n      \"Cannot extend a table schema that uses decoding/encoding middleware with system fields\",\n    );\n  }\n  return new SchemaTransformation.Transformation(\n    wrapGetter(transformation.decode),\n    wrapGetter(transformation.encode),\n  );\n};\n\n/**\n * Builds an AST walker that adds the given system-field property signatures to\n * every object node of a schema's AST — including each step of its encoding\n * chain — wrapping transformations so the fields survive them.\n */\nconst makeExtendAst = (\n  systemPropertySignatures: ReadonlyArray<SchemaAST.PropertySignature>,\n) => {\n  const extendEncoding = (encoding: SchemaAST.Encoding): SchemaAST.Encoding =>\n    Array.map(\n      encoding,\n      (link) =>\n        new SchemaAST.Link(\n          extendAst(link.to),\n          wrapTransformation(link.transformation),\n        ),\n    );\n\n  const extendAst = (ast: SchemaAST.AST): SchemaAST.AST => {\n    if (SchemaAST.isUnion(ast)) {\n      return new SchemaAST.Union(\n        Array.map(ast.types, extendAst),\n        ast.mode,\n        ast.annotations,\n        ast.checks,\n        ast.encoding === undefined ? undefined : extendEncoding(ast.encoding),\n        ast.context,\n        ast.encodingChecks,\n      );\n    }\n    if (SchemaAST.isSuspend(ast)) {\n      return new SchemaAST.Suspend(\n        () => extendAst(ast.thunk()),\n        ast.annotations,\n        undefined,\n        ast.encoding === undefined ? undefined : extendEncoding(ast.encoding),\n        ast.context,\n      );\n    }\n    if (SchemaAST.isObjects(ast)) {\n      return new SchemaAST.Objects(\n        Array.appendAll(ast.propertySignatures, systemPropertySignatures),\n        ast.indexSignatures,\n        ast.annotations,\n        ast.checks,\n        ast.encoding === undefined ? undefined : extendEncoding(ast.encoding),\n        ast.context,\n        ast.encodingChecks,\n      );\n    }\n    throw new Error(\n      ast._tag === \"Declaration\"\n        ? \"Cannot extend a `Declaration` schema (such as a `Schema.Class`) with system fields: its decoded values are constructed instances, which cannot gain extra fields. Use a plain `Schema.Struct`, or transform to one with `Schema.decodeTo`.\"\n        : `Cannot extend a \\`${ast._tag}\\` schema node with system fields: a table schema must resolve to an object shape at every step of its encoding.`,\n    );\n  };\n\n  return extendAst;\n};\n\n/**\n * Extend a table schema with Convex system fields.\n *\n * A plain `Struct` gains the fields via `Schema.fieldsAssign` and a `Union`\n * has them distributed across its members, preserving the schema's\n * `Struct`/`Union` structure. Any other object-shaped schema — one built with\n * `Schema.decodeTo`/`Schema.encodeKeys`, a branded struct, a suspended schema\n * — is extended at the AST level: every object node in its encoding chain\n * gains the system fields, and each transformation is wrapped so the fields\n * bypass the user-defined getters. Schemas that do not resolve to an object\n * shape at every step (such as `Schema.Class`, whose decoded values are class\n * instances) are rejected with a descriptive error.\n *\n * Note that struct-level checks on an extended schema observe the value with\n * the system fields attached, and encoding an extended schema emits the system\n * fields alongside the table fields.\n */\nexport const extendWithSystemFields = <\n  TableName extends string,\n  TableSchema extends Schema.Codec<any, any>,\n>(\n  tableName: TableName,\n  schema: TableSchema,\n): ExtendWithSystemFields<TableName, TableSchema> => {\n  const system = SystemFields(tableName).fields;\n\n  const extendAst = makeExtendAst(\n    pipe(\n      system,\n      Record.toEntries,\n      Array.map(\n        ([name, field]) => new SchemaAST.PropertySignature(name, field.ast),\n      ),\n    ),\n  );\n\n  const extend = (s: Schema.Top): Schema.Top => {\n    if (\n      s.ast.encoding === undefined &&\n      SchemaAST.isUnion(s.ast) &&\n      Array.isArray(\n        (s as Partial<Schema.Union<ReadonlyArray<Schema.Top>>>).members,\n      )\n    ) {\n      return Schema.Union(\n        Array.map(\n          (s as Schema.Union<ReadonlyArray<Schema.Top>>).members,\n          extend,\n        ),\n      );\n    }\n    if (\n      s.ast.encoding === undefined &&\n      SchemaAST.isObjects(s.ast) &&\n      typeof (s as Partial<Schema.Struct<Schema.Struct.Fields>>).mapFields ===\n        \"function\"\n    ) {\n      return Schema.fieldsAssign(system)(\n        s as Schema.Struct<Schema.Struct.Fields>,\n      );\n    }\n    return Schema.make(extendAst(s.ast));\n  };\n\n  return extend(schema) as unknown as ExtendWithSystemFields<\n    TableName,\n    TableSchema\n  >;\n};\n\n/**\n * Applies the system fields to a single struct, mirroring `Schema.fieldsAssign`.\n * Any other (already-extended or opaque) schema falls back to a `Codec` carrying\n * the system-field document shape.\n */\ntype ApplySystemFields<TableName extends string, S> =\n  S extends Schema.Struct<infer Fields extends Schema.Struct.Fields>\n    ? Schema.Struct<\n        Struct.Simplify<Struct.Assign<Fields, SystemFieldsFor<TableName>>>\n      >\n    : S extends Schema.Codec<infer Type, infer Encoded>\n      ? Schema.Codec<\n          WithSystemFields<TableName, Type>,\n          WithSystemFields<TableName, Encoded>\n        >\n      : never;\n\n/**\n * Extend a table schema with Convex system fields at the type level.\n *\n * This mirrors the runtime {@link extendWithSystemFields}: a `Struct` gains the\n * system fields directly (matching `Schema.fieldsAssign`), and a `Union` has\n * them distributed across its members (matching\n * `union.mapMembers(Tuple.map(Schema.fieldsAssign(...)))`). The `Struct`/`Union`\n * structure is preserved rather than collapsed to a bare `Codec`; any other\n * schema falls back to a `Codec` carrying the system-field document shape,\n * matching the runtime's AST-level extension.\n */\nexport type ExtendWithSystemFields<\n  TableName extends string,\n  TableSchema extends Schema.Top,\n> =\n  TableSchema extends Schema.Union<\n    infer Members extends ReadonlyArray<Schema.Top>\n  >\n    ? Schema.Union<\n        Struct.Simplify<\n          Readonly<{\n            [K in keyof Members]: ExtendWithSystemFields<TableName, Members[K]>;\n          }>\n        >\n      >\n    : ApplySystemFields<TableName, TableSchema>;\n\n/**\n * The decoded/encoded document shape: a table's fields plus Convex's system\n * fields. Deliberately a bare intersection (no `Expand`/`Simplify`) — flattening\n * it with a homomorphic mapped type collapses to `{ [x: string]: any }` when\n * `Document` is still an unresolved generic, which breaks structural\n * comparability in the database reader/writer plumbing.\n */\nexport type WithSystemFields<\n  TableName extends string,\n  Document,\n> = Document extends unknown\n  ? IdField<TableName> & NonIdSystemFields & Document\n  : never;\n"],"mappings":"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"}

package/dist/UserIdentity.d.ts

@@ -1,58 +1,24 @@
 import * as Schema from "effect/Schema";
 export declare const UserIdentity: <CustomClaimsFields extends Schema.Struct.Fields>(customClaimsFields: CustomClaimsFields) => Schema.Struct<CustomClaimsFields & {
-    tokenIdentifier: typeof Schema.String;
-    subject: typeof Schema.String;
-    issuer: typeof Schema.String;
-    name: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    givenName: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    familyName: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    nickname: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    preferredUsername: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    profileUrl: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    pictureUrl: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    email: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    emailVerified: Schema.optionalWith<typeof Schema.Boolean, {
-        exact: true;
-    }>;
-    gender: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    birthday: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    timezone: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    language: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    phoneNumber: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    phoneNumberVerified: Schema.optionalWith<typeof Schema.Boolean, {
-        exact: true;
-    }>;
-    address: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
-    updatedAt: Schema.optionalWith<typeof Schema.String, {
-        exact: true;
-    }>;
+    readonly tokenIdentifier: Schema.String;
+    readonly subject: Schema.String;
+    readonly issuer: Schema.String;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly givenName: Schema.optionalKey<Schema.String>;
+    readonly familyName: Schema.optionalKey<Schema.String>;
+    readonly nickname: Schema.optionalKey<Schema.String>;
+    readonly preferredUsername: Schema.optionalKey<Schema.String>;
+    readonly profileUrl: Schema.optionalKey<Schema.String>;
+    readonly pictureUrl: Schema.optionalKey<Schema.String>;
+    readonly email: Schema.optionalKey<Schema.String>;
+    readonly emailVerified: Schema.optionalKey<Schema.Boolean>;
+    readonly gender: Schema.optionalKey<Schema.String>;
+    readonly birthday: Schema.optionalKey<Schema.String>;
+    readonly timezone: Schema.optionalKey<Schema.String>;
+    readonly language: Schema.optionalKey<Schema.String>;
+    readonly phoneNumber: Schema.optionalKey<Schema.String>;
+    readonly phoneNumberVerified: Schema.optionalKey<Schema.Boolean>;
+    readonly address: Schema.optionalKey<Schema.String>;
+    readonly updatedAt: Schema.optionalKey<Schema.String>;
 }>;
 //# sourceMappingURL=UserIdentity.d.ts.map

package/dist/UserIdentity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserIdentity.d.ts","sourceRoot":"","sources":["../src/UserIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,YAAY,GAAI,kBAAkB,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAC1E,oBAAoB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBpC,CAAC"}
+{"version":3,"file":"UserIdentity.d.ts","sourceRoot":"","sources":["../src/UserIdentity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,YAAY,GAAI,kBAAkB,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAC1E,oBAAoB,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAwBpC,CAAC"}

package/dist/UserIdentity.js

@@ -8,23 +8,23 @@ const UserIdentity = (customClaimsFields) => Schema.Struct({
 	tokenIdentifier: Schema.String,
 	subject: Schema.String,
 	issuer: Schema.String,
-	name: Schema.optionalWith(Schema.String, { exact: true }),
-	givenName: Schema.optionalWith(Schema.String, { exact: true }),
-	familyName: Schema.optionalWith(Schema.String, { exact: true }),
-	nickname: Schema.optionalWith(Schema.String, { exact: true }),
-	preferredUsername: Schema.optionalWith(Schema.String, { exact: true }),
-	profileUrl: Schema.optionalWith(Schema.String, { exact: true }),
-	pictureUrl: Schema.optionalWith(Schema.String, { exact: true }),
-	email: Schema.optionalWith(Schema.String, { exact: true }),
-	emailVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),
-	gender: Schema.optionalWith(Schema.String, { exact: true }),
-	birthday: Schema.optionalWith(Schema.String, { exact: true }),
-	timezone: Schema.optionalWith(Schema.String, { exact: true }),
-	language: Schema.optionalWith(Schema.String, { exact: true }),
-	phoneNumber: Schema.optionalWith(Schema.String, { exact: true }),
-	phoneNumberVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),
-	address: Schema.optionalWith(Schema.String, { exact: true }),
-	updatedAt: Schema.optionalWith(Schema.String, { exact: true })
+	name: Schema.optionalKey(Schema.String),
+	givenName: Schema.optionalKey(Schema.String),
+	familyName: Schema.optionalKey(Schema.String),
+	nickname: Schema.optionalKey(Schema.String),
+	preferredUsername: Schema.optionalKey(Schema.String),
+	profileUrl: Schema.optionalKey(Schema.String),
+	pictureUrl: Schema.optionalKey(Schema.String),
+	email: Schema.optionalKey(Schema.String),
+	emailVerified: Schema.optionalKey(Schema.Boolean),
+	gender: Schema.optionalKey(Schema.String),
+	birthday: Schema.optionalKey(Schema.String),
+	timezone: Schema.optionalKey(Schema.String),
+	language: Schema.optionalKey(Schema.String),
+	phoneNumber: Schema.optionalKey(Schema.String),
+	phoneNumberVerified: Schema.optionalKey(Schema.Boolean),
+	address: Schema.optionalKey(Schema.String),
+	updatedAt: Schema.optionalKey(Schema.String)
 });
 
 //#endregion

package/dist/UserIdentity.js.map

@@ -1 +1 @@
-{"version":3,"file":"UserIdentity.js","names":[],"sources":["../src/UserIdentity.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nexport const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(\n  customClaimsFields: CustomClaimsFields,\n) =>\n  Schema.Struct({\n    ...customClaimsFields,\n    tokenIdentifier: Schema.String,\n    subject: Schema.String,\n    issuer: Schema.String,\n    name: Schema.optionalWith(Schema.String, { exact: true }),\n    givenName: Schema.optionalWith(Schema.String, { exact: true }),\n    familyName: Schema.optionalWith(Schema.String, { exact: true }),\n    nickname: Schema.optionalWith(Schema.String, { exact: true }),\n    preferredUsername: Schema.optionalWith(Schema.String, { exact: true }),\n    profileUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    pictureUrl: Schema.optionalWith(Schema.String, { exact: true }),\n    email: Schema.optionalWith(Schema.String, { exact: true }),\n    emailVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    gender: Schema.optionalWith(Schema.String, { exact: true }),\n    birthday: Schema.optionalWith(Schema.String, { exact: true }),\n    timezone: Schema.optionalWith(Schema.String, { exact: true }),\n    language: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumber: Schema.optionalWith(Schema.String, { exact: true }),\n    phoneNumberVerified: Schema.optionalWith(Schema.Boolean, { exact: true }),\n    address: Schema.optionalWith(Schema.String, { exact: true }),\n    updatedAt: Schema.optionalWith(Schema.String, { exact: true }),\n  });\n"],"mappings":";;;;;AAEA,MAAa,gBACX,uBAEA,OAAO,OAAO;CACZ,GAAG;CACH,iBAAiB,OAAO;CACxB,SAAS,OAAO;CAChB,QAAQ,OAAO;CACf,MAAM,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACzD,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC9D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,mBAAmB,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CACtE,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,YAAY,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,OAAO,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC1D,eAAe,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACnE,QAAQ,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC3D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,UAAU,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC7D,aAAa,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAChE,qBAAqB,OAAO,aAAa,OAAO,SAAS,EAAE,OAAO,MAAM,CAAC;CACzE,SAAS,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC5D,WAAW,OAAO,aAAa,OAAO,QAAQ,EAAE,OAAO,MAAM,CAAC;CAC/D,CAAC"}
+{"version":3,"file":"UserIdentity.js","names":[],"sources":["../src/UserIdentity.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nexport const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(\n  customClaimsFields: CustomClaimsFields,\n) =>\n  Schema.Struct({\n    ...customClaimsFields,\n    tokenIdentifier: Schema.String,\n    subject: Schema.String,\n    issuer: Schema.String,\n    name: Schema.optionalKey(Schema.String),\n    givenName: Schema.optionalKey(Schema.String),\n    familyName: Schema.optionalKey(Schema.String),\n    nickname: Schema.optionalKey(Schema.String),\n    preferredUsername: Schema.optionalKey(Schema.String),\n    profileUrl: Schema.optionalKey(Schema.String),\n    pictureUrl: Schema.optionalKey(Schema.String),\n    email: Schema.optionalKey(Schema.String),\n    emailVerified: Schema.optionalKey(Schema.Boolean),\n    gender: Schema.optionalKey(Schema.String),\n    birthday: Schema.optionalKey(Schema.String),\n    timezone: Schema.optionalKey(Schema.String),\n    language: Schema.optionalKey(Schema.String),\n    phoneNumber: Schema.optionalKey(Schema.String),\n    phoneNumberVerified: Schema.optionalKey(Schema.Boolean),\n    address: Schema.optionalKey(Schema.String),\n    updatedAt: Schema.optionalKey(Schema.String),\n  });\n"],"mappings":";;;;;AAEA,MAAa,gBACX,uBAEA,OAAO,OAAO;CACZ,GAAG;CACH,iBAAiB,OAAO;CACxB,SAAS,OAAO;CAChB,QAAQ,OAAO;CACf,MAAM,OAAO,YAAY,OAAO,OAAO;CACvC,WAAW,OAAO,YAAY,OAAO,OAAO;CAC5C,YAAY,OAAO,YAAY,OAAO,OAAO;CAC7C,UAAU,OAAO,YAAY,OAAO,OAAO;CAC3C,mBAAmB,OAAO,YAAY,OAAO,OAAO;CACpD,YAAY,OAAO,YAAY,OAAO,OAAO;CAC7C,YAAY,OAAO,YAAY,OAAO,OAAO;CAC7C,OAAO,OAAO,YAAY,OAAO,OAAO;CACxC,eAAe,OAAO,YAAY,OAAO,QAAQ;CACjD,QAAQ,OAAO,YAAY,OAAO,OAAO;CACzC,UAAU,OAAO,YAAY,OAAO,OAAO;CAC3C,UAAU,OAAO,YAAY,OAAO,OAAO;CAC3C,UAAU,OAAO,YAAY,OAAO,OAAO;CAC3C,aAAa,OAAO,YAAY,OAAO,OAAO;CAC9C,qBAAqB,OAAO,YAAY,OAAO,QAAQ;CACvD,SAAS,OAAO,YAAY,OAAO,OAAO;CAC1C,WAAW,OAAO,YAAY,OAAO,OAAO;CAC7C,CAAC"}