@confect/core 9.0.0-next.5 → 9.0.0-next.6

package/dist/Lazy.js

@@ -0,0 +1,44 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+
+//#region src/Lazy.ts
+var Lazy_exports = /* @__PURE__ */ __exportAll({ defineProperty: () => defineProperty });
+/**
+* Install a lazy memoised property on `target`. The first access runs
+* `compute()` and replaces the getter with a plain, non-writable data
+* property whose value is the computed result. Subsequent accesses hit
+* the V8 fast path for own data properties — no function call, identical
+* returned reference — so first and second-and-subsequent accesses are
+* observably indistinguishable.
+*
+* The replacement property is `enumerable: true` so the lazy property
+* still participates in `Object.keys` / `JSON.stringify` after it
+* materialises, matching the shape of a plain data property. The property
+* is also `enumerable` before materialising, so presence checks
+* (`"key" in target`, `Object.hasOwn(target, key)`) observe it without
+* forcing the computation.
+*
+* This is the single shared implementation consumed across packages (e.g.
+* `@confect/core`'s lazy `FunctionSpec` schemas and `@confect/server`'s lazy
+* `Table` `Fields` / `Doc` / `tableDefinition`), so there is no chance of the
+* two drifting apart.
+*/
+const defineProperty = (target, key, compute) => {
+	Object.defineProperty(target, key, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const value = compute();
+			Object.defineProperty(this, key, {
+				value,
+				writable: false,
+				enumerable: true,
+				configurable: false
+			});
+			return value;
+		}
+	});
+};
+
+//#endregion
+export { Lazy_exports, defineProperty };
+//# sourceMappingURL=Lazy.js.map

package/dist/Lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Lazy.js","names":[],"sources":["../src/Lazy.ts"],"sourcesContent":["/**\n * Install a lazy memoised property on `target`. The first access runs\n * `compute()` and replaces the getter with a plain, non-writable data\n * property whose value is the computed result. Subsequent accesses hit\n * the V8 fast path for own data properties — no function call, identical\n * returned reference — so first and second-and-subsequent accesses are\n * observably indistinguishable.\n *\n * The replacement property is `enumerable: true` so the lazy property\n * still participates in `Object.keys` / `JSON.stringify` after it\n * materialises, matching the shape of a plain data property. The property\n * is also `enumerable` before materialising, so presence checks\n * (`\"key\" in target`, `Object.hasOwn(target, key)`) observe it without\n * forcing the computation.\n *\n * This is the single shared implementation consumed across packages (e.g.\n * `@confect/core`'s lazy `FunctionSpec` schemas and `@confect/server`'s lazy\n * `Table` `Fields` / `Doc` / `tableDefinition`), so there is no chance of the\n * two drifting apart.\n */\nexport const defineProperty = <T extends object, K extends PropertyKey>(\n  target: T,\n  key: K,\n  compute: () => unknown,\n): void => {\n  Object.defineProperty(target, key, {\n    configurable: true,\n    enumerable: true,\n    get(this: T) {\n      const value = compute();\n      Object.defineProperty(this, key, {\n        value,\n        writable: false,\n        enumerable: true,\n        configurable: false,\n      });\n      return value;\n    },\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,kBACX,QACA,KACA,YACS;AACT,QAAO,eAAe,QAAQ,KAAK;EACjC,cAAc;EACd,YAAY;EACZ,MAAa;GACX,MAAM,QAAQ,SAAS;AACvB,UAAO,eAAe,MAAM,KAAK;IAC/B;IACA,UAAU;IACV,YAAY;IACZ,cAAc;IACf,CAAC;AACF,UAAO;;EAEV,CAAC"}

package/dist/Ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ref.d.ts","names":[],"sources":["../src/Ref.ts"],"mappings":"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"}
+{"version":3,"file":"Ref.d.ts","names":[],"sources":["../src/Ref.ts"],"mappings":"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"}

package/dist/Ref.js

@@ -26,7 +26,7 @@ const make = (functionNamespace, functionSpec) => ({
 });
 const getConvexFunctionName = (ref) => `${ref.functionNamespace}:${ref.functionSpec.name}`;
 const getFunctionReference = (ref) => makeFunctionReference(getConvexFunctionName(ref));
-const hasErrorSchema = (ref) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => confectFunctionProvenance.error !== void 0), Match.tag("Convex", () => false), Match.exhaustive);
+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 encodeArgsSync = (ref, args) => Match.value(ref.functionSpec.functionProvenance).pipe(Match.tag("Confect", (confectFunctionProvenance) => Schema.encodeSync(confectFunctionProvenance.args)(args)), Match.tag("Convex", () => args), Match.exhaustive);
@@ -56,13 +56,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) => confectFunctionProvenance.error !== void 0 ? 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.decode(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) => confectFunctionProvenance.error !== void 0 ? 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) => confectFunctionProvenance.error !== void 0 ? 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.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;
 /**
 * 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

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 { Effect, Match, Option, Schema } from \"effect\";\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\nexport const getFunctionReference = <Ref_ extends Any>(\n  ref: Ref_,\n): FunctionReference<Ref_> =>\n  makeFunctionReference(getConvexFunctionName(ref)) as FunctionReference<Ref_>;\n\nexport const hasErrorSchema = (ref: Any): boolean =>\n  Match.value(ref.functionSpec.functionProvenance).pipe(\n    Match.tag(\n      \"Confect\",\n      (confectFunctionProvenance) =>\n        confectFunctionProvenance.error !== undefined,\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 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      confectFunctionProvenance.error !== undefined\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      confectFunctionProvenance.error !== undefined\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          confectFunctionProvenance.error !== undefined\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":"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"}
+{"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 { Effect, Match, Option, Schema } from \"effect\";\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\nexport const getFunctionReference = <Ref_ extends Any>(\n  ref: Ref_,\n): FunctionReference<Ref_> =>\n  makeFunctionReference(getConvexFunctionName(ref)) as FunctionReference<Ref_>;\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 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":"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"}

package/dist/Spec.d.ts

@@ -14,26 +14,8 @@ interface Spec<Runtime$1 extends Runtime, Groups_ extends AnyWithPropsWithRuntim
   readonly [TypeId]: TypeId;
   readonly runtime: Runtime$1;
   readonly groups: { [GroupName in Name<Groups_>]: WithName<Groups_, GroupName> };
-  /**
-   * Mapping from an imported leaf `GroupSpec` reference to its full dot-path
-   * within this spec tree. Populated by codegen-emitted `_generated/spec.ts`
-   * via {@link Spec#addPath}; consumed by `FunctionImpl.make` /
-   * `GroupImpl.make` to resolve a spec's location without walking the tree.
-   */
-  readonly paths: ReadonlyMap<AnyWithProps$1, string>;
   add<Group extends AnyWithPropsWithRuntime$1<Runtime$1>>(group: Group): Spec<Runtime$1, Groups_ | Group>;
   addAt<const Name$1 extends string, Group extends AnyWithPropsWithRuntime$1<Runtime$1>>(name: Name$1, group: Group): Spec<Runtime$1, Groups_ | NamedAt<Group, Name$1>>;
-  /**
-   * Register the imported leaf `group` at `path` within this spec's path
-   * mapping. Returns a new `Spec` with one additional entry. The tree shape
-   * (`groups`) is unaffected — registration and tree assembly are
-   * independent steps, both performed by codegen in `_generated/spec.ts`.
-   *
-   * Re-registering the same group with the same path is a no-op (cheap
-   * defense for codegen watch-mode re-imports). Re-registering with a
-   * different path throws.
-   */
-  addPath(group: AnyWithProps$1, path: string): Spec<Runtime$1, Groups_>;
 }
 interface Any {
   readonly [TypeId]: TypeId;
@@ -44,11 +26,10 @@ type Groups<Spec_ extends AnyWithProps> = Spec_["groups"][keyof Spec_["groups"]]
 declare const make: () => Spec<"Convex">;
 declare const makeNode: () => Spec<"Node">;
 /**
- * Merges a Convex spec with an optional Node spec for use with `Api.make`.
+ * Merges a Convex spec with an optional Node spec into a single assembled
+ * spec (used by codegen to build `Refs.make` and to enumerate function paths).
  * When `nodeSpec` is provided, its groups are merged under a "node" namespace,
- * mirroring the structure used by `Refs.make`. The node spec's `paths`
- * entries are re-prefixed with `"node."` so they continue to identify the
- * same leaves at their new positions in the merged tree.
+ * mirroring the structure used by `Refs.make`.
  */
 declare const merge: <ConvexSpec extends AnyWithPropsWithRuntime<"Convex">, NodeSpec extends AnyWithPropsWithRuntime<"Node">>(convexSpec: ConvexSpec, nodeSpec?: NodeSpec) => AnyWithProps;
 //#endregion

package/dist/Spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Spec.d.ts","names":[],"sources":["../src/Spec.ts"],"mappings":";;;;;;;cAKa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,cAG5B,YAAA,GACX,CAAA,cACC,CAAA,IAAK,uBAAA;AAAA,cAKK,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,uBAAA;AAAA,UAK5B,IAAA,mBACC,OAAA,kBACA,yBAAA,CAAkC,SAAA;EAAA,UAExC,MAAA,GAAS,MAAA;EAAA,SACV,OAAA,EAAS,SAAA;EAAA,SACT,MAAA,kBACO,IAAA,CAAe,OAAA,IAAW,QAAA,CACtC,OAAA,EACA,SAAA;;;;;;;WASK,KAAA,EAAO,WAAA,CAAY,cAAA;EAE5B,GAAA,eAAkB,yBAAA,CAAkC,SAAA,GAClD,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,KAAA;EAE3B,KAAA,4CAEgB,yBAAA,CAAkC,SAAA,GAEhD,IAAA,EAAM,MAAA,EACN,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,OAAA,CAAkB,KAAA,EAAO,MAAA;EAhDnC;;AACnB;;;;;AAEA;;;EAyDE,OAAA,CAAQ,KAAA,EAAO,cAAA,EAAwB,IAAA,WAAe,IAAA,CAAK,SAAA,EAAS,OAAA;AAAA;AAAA,UAGrD,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,IAAA,CACpC,OAAA,EACA,cAAA;AAAA,UAGe,uBAAA,mBACC,OAAA,UACR,IAAA,CAAK,SAAA,EAAS,yBAAA,CAAkC,SAAA;AAAA,KAE9C,MAAA,eAAqB,YAAA,IAC/B,KAAA,iBAAsB,KAAA;AAAA,cAwFX,IAAA,QAAW,IAAA;AAAA,cAGX,QAAA,QAAe,IAAA;;;;AA3J5B;;;;cAqKa,KAAA,sBACQ,uBAAA,6BACF,uBAAA,UAEjB,UAAA,EAAY,UAAA,EACZ,QAAA,GAAW,QAAA,KACV,YAAA"}
+{"version":3,"file":"Spec.d.ts","names":[],"sources":["../src/Spec.ts"],"mappings":";;;;;;;cAIa,MAAA;AAAA,KACD,MAAA,UAAgB,MAAA;AAAA,cAEf,MAAA,GAAU,CAAA,cAAa,CAAA,IAAK,YAAA;AAAA,cAG5B,YAAA,GACX,CAAA,cACC,CAAA,IAAK,uBAAA;AAAA,cAKK,UAAA,GAAc,CAAA,cAAa,CAAA,IAAK,uBAAA;AAAA,UAK5B,IAAA,mBACC,OAAA,kBACA,yBAAA,CAAkC,SAAA;EAAA,UAExC,MAAA,GAAS,MAAA;EAAA,SACV,OAAA,EAAS,SAAA;EAAA,SACT,MAAA,kBACO,IAAA,CAAe,OAAA,IAAW,QAAA,CACtC,OAAA,EACA,SAAA;EAIJ,GAAA,eAAkB,yBAAA,CAAkC,SAAA,GAClD,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,KAAA;EAE3B,KAAA,4CAEgB,yBAAA,CAAkC,SAAA,GAEhD,IAAA,EAAM,MAAA,EACN,KAAA,EAAO,KAAA,GACN,IAAA,CAAK,SAAA,EAAS,OAAA,GAAU,OAAA,CAAkB,KAAA,EAAO,MAAA;AAAA;AAAA,UAGrC,GAAA;EAAA,UACL,MAAA,GAAS,MAAA;AAAA;AAAA,UAGJ,YAAA,SAAqB,IAAA,CACpC,OAAA,EACA,cAAA;AAAA,UAGe,uBAAA,mBACC,OAAA,UACR,IAAA,CAAK,SAAA,EAAS,yBAAA,CAAkC,SAAA;AAAA,KAE9C,MAAA,eAAqB,YAAA,IAC/B,KAAA,iBAAsB,KAAA;AAAA,cAuCX,IAAA,QAAW,IAAA;AAAA,cAGX,QAAA,QAAe,IAAA;;;;AAjG5B;;;cA0Ga,KAAA,sBACQ,uBAAA,6BACF,uBAAA,UAEjB,UAAA,EAAY,UAAA,EACZ,QAAA,GAAW,QAAA,KACV,YAAA"}

package/dist/Spec.js

@@ -1,7 +1,6 @@
 import { __exportAll } from "./_virtual/_rolldown/runtime.js";
-import { validateConfectFunctionIdentifier } from "./internal/utils.js";
 import { makeNodeAt, withName } from "./GroupSpec.js";
-import { Array, Option, Predicate, Record, String } from "effect";
+import { Array, Option, Predicate, Record } from "effect";
 
 //#region src/Spec.ts
 var Spec_exports = /* @__PURE__ */ __exportAll({
@@ -17,68 +16,38 @@ const TypeId = "@confect/core/Spec";
 const isSpec = (u) => Predicate.hasProperty(u, TypeId);
 const isConvexSpec = (u) => Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "runtime") && u.runtime === "Convex";
 const isNodeSpec = (u) => Predicate.hasProperty(u, TypeId) && Predicate.hasProperty(u, "runtime") && u.runtime === "Node";
-const validatePath = (path) => {
-	if (path.length === 0) throw new Error("Expected a non-empty Confect group path, but received an empty string.");
-	const segments = String.split(path, ".");
-	for (const segment of segments) {
-		if (segment.length === 0) throw new Error(`Expected a Confect group path made of dot-separated identifier segments, but received: "${path}".`);
-		validateConfectFunctionIdentifier(segment);
-	}
-};
 const Proto = {
 	[TypeId]: TypeId,
 	add(group) {
 		return makeProto({
 			runtime: this.runtime,
-			groups: Record.set(this.groups, group.name, group),
-			paths: this.paths
+			groups: Record.set(this.groups, group.name, group)
 		});
 	},
 	addAt(name, group) {
 		return makeProto({
 			runtime: this.runtime,
-			groups: Record.set(this.groups, name, withName(name, group)),
-			paths: this.paths
-		});
-	},
-	addPath(group, path) {
-		validatePath(path);
-		const existing = this.paths.get(group);
-		if (existing !== void 0) {
-			if (existing === path) return this;
-			throw new Error(`Spec.addPath: the provided GroupSpec is already registered at "${existing}", but was re-registered at "${path}". Each GroupSpec must have at most one path.`);
-		}
-		const nextPaths = new Map(this.paths);
-		nextPaths.set(group, path);
-		return makeProto({
-			runtime: this.runtime,
-			groups: this.groups,
-			paths: nextPaths
+			groups: Record.set(this.groups, name, withName(name, group))
 		});
 	}
 };
-const makeProto = ({ runtime, groups, paths }) => Object.assign(Object.create(Proto), {
+const makeProto = ({ runtime, groups }) => Object.assign(Object.create(Proto), {
 	runtime,
-	groups,
-	paths
+	groups
 });
-const emptyPaths = () => /* @__PURE__ */ new Map();
 const make = () => makeProto({
 	runtime: "Convex",
-	groups: {},
-	paths: emptyPaths()
+	groups: {}
 });
 const makeNode = () => makeProto({
 	runtime: "Node",
-	groups: {},
-	paths: emptyPaths()
+	groups: {}
 });
 /**
-* Merges a Convex spec with an optional Node spec for use with `Api.make`.
+* Merges a Convex spec with an optional Node spec into a single assembled
+* spec (used by codegen to build `Refs.make` and to enumerate function paths).
 * When `nodeSpec` is provided, its groups are merged under a "node" namespace,
-* mirroring the structure used by `Refs.make`. The node spec's `paths`
-* entries are re-prefixed with `"node."` so they continue to identify the
-* same leaves at their new positions in the merged tree.
+* mirroring the structure used by `Refs.make`.
 */
 const merge = (convexSpec, nodeSpec) => {
 	const groups = Option.fromNullable(nodeSpec).pipe(Option.map((nodeSpec_) => Array.reduce(Record.toEntries(nodeSpec_.groups), makeNodeAt("node"), (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group))), Option.match({
@@ -88,12 +57,9 @@ const merge = (convexSpec, nodeSpec) => {
 			node: nodeGroup
 		})
 	}));
-	const paths = new Map(convexSpec.paths);
-	if (nodeSpec !== void 0) for (const [group, path] of nodeSpec.paths) paths.set(group, `node.${path}`);
 	return Object.assign(Object.create(Proto), {
 		runtime: "Convex",
-		groups,
-		paths
+		groups
 	});
 };
 

package/dist/Spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"Spec.js","names":["GroupSpec.withName","GroupSpec.makeNodeAt"],"sources":["../src/Spec.ts"],"sourcesContent":["import { Array, Option, Predicate, Record, String } from \"effect\";\nimport * as GroupSpec from \"./GroupSpec\";\nimport type * as RuntimeAndFunctionType from \"./RuntimeAndFunctionType\";\nimport { validateConfectFunctionIdentifier } from \"./internal/utils\";\n\nexport const TypeId = \"@confect/core/Spec\";\nexport type TypeId = typeof TypeId;\n\nexport const isSpec = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\n\nexport const isConvexSpec = (\n  u: unknown,\n): u is AnyWithPropsWithRuntime<\"Convex\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Convex\";\n\nexport const isNodeSpec = (u: unknown): u is AnyWithPropsWithRuntime<\"Node\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Node\";\n\nexport interface Spec<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime> = never,\n> {\n  readonly [TypeId]: TypeId;\n  readonly runtime: Runtime;\n  readonly groups: {\n    [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<\n      Groups_,\n      GroupName\n    >;\n  };\n  /**\n   * Mapping from an imported leaf `GroupSpec` reference to its full dot-path\n   * within this spec tree. Populated by codegen-emitted `_generated/spec.ts`\n   * via {@link Spec#addPath}; consumed by `FunctionImpl.make` /\n   * `GroupImpl.make` to resolve a spec's location without walking the tree.\n   */\n  readonly paths: ReadonlyMap<GroupSpec.AnyWithProps, string>;\n\n  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(\n    group: Group,\n  ): Spec<Runtime, Groups_ | Group>;\n\n  addAt<\n    const Name extends string,\n    Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n  >(\n    name: Name,\n    group: Group,\n  ): Spec<Runtime, Groups_ | GroupSpec.NamedAt<Group, Name>>;\n\n  /**\n   * Register the imported leaf `group` at `path` within this spec's path\n   * mapping. Returns a new `Spec` with one additional entry. The tree shape\n   * (`groups`) is unaffected — registration and tree assembly are\n   * independent steps, both performed by codegen in `_generated/spec.ts`.\n   *\n   * Re-registering the same group with the same path is a no-op (cheap\n   * defense for codegen watch-mode re-imports). Re-registering with a\n   * different path throws.\n   */\n  addPath(group: GroupSpec.AnyWithProps, path: string): Spec<Runtime, Groups_>;\n}\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Spec<\n  RuntimeAndFunctionType.Runtime,\n  GroupSpec.AnyWithProps\n> {}\n\nexport interface AnyWithPropsWithRuntime<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}\n\nexport type Groups<Spec_ extends AnyWithProps> =\n  Spec_[\"groups\"][keyof Spec_[\"groups\"]];\n\nconst validatePath = (path: string): void => {\n  if (path.length === 0) {\n    throw new Error(\n      \"Expected a non-empty Confect group path, but received an empty string.\",\n    );\n  }\n\n  const segments = String.split(path, \".\");\n\n  for (const segment of segments) {\n    if (segment.length === 0) {\n      throw new Error(\n        `Expected a Confect group path made of dot-separated identifier segments, but received: \"${path}\".`,\n      );\n    }\n    validateConfectFunctionIdentifier(segment);\n  }\n};\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, group.name, group),\n      paths: this.paths,\n    });\n  },\n\n  addAt<Group extends GroupSpec.AnyWithProps>(\n    this: AnyWithProps,\n    name: string,\n    group: Group,\n  ) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),\n      paths: this.paths,\n    });\n  },\n\n  addPath(this: AnyWithProps, group: GroupSpec.AnyWithProps, path: string) {\n    validatePath(path);\n\n    const existing = this.paths.get(group);\n    if (existing !== undefined) {\n      if (existing === path) {\n        return this;\n      }\n      throw new Error(\n        `Spec.addPath: the provided GroupSpec is already registered at \"${existing}\", but was re-registered at \"${path}\". Each GroupSpec must have at most one path.`,\n      );\n    }\n\n    const nextPaths = new Map(this.paths);\n    nextPaths.set(group, path);\n\n    return makeProto({\n      runtime: this.runtime,\n      groups: this.groups,\n      paths: nextPaths,\n    });\n  },\n};\n\nconst makeProto = <\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n>({\n  runtime,\n  groups,\n  paths,\n}: {\n  runtime: Runtime;\n  groups: Record.ReadonlyRecord<string, Groups_>;\n  paths: ReadonlyMap<GroupSpec.AnyWithProps, string>;\n}): Spec<Runtime, Groups_> =>\n  Object.assign(Object.create(Proto), {\n    runtime,\n    groups,\n    paths,\n  });\n\nconst emptyPaths = (): ReadonlyMap<GroupSpec.AnyWithProps, string> => new Map();\n\nexport const make = (): Spec<\"Convex\"> =>\n  makeProto({ runtime: \"Convex\", groups: {}, paths: emptyPaths() });\n\nexport const makeNode = (): Spec<\"Node\"> =>\n  makeProto({ runtime: \"Node\", groups: {}, paths: emptyPaths() });\n\n/**\n * Merges a Convex spec with an optional Node spec for use with `Api.make`.\n * When `nodeSpec` is provided, its groups are merged under a \"node\" namespace,\n * mirroring the structure used by `Refs.make`. The node spec's `paths`\n * entries are re-prefixed with `\"node.\"` so they continue to identify the\n * same leaves at their new positions in the merged tree.\n */\nexport const merge = <\n  ConvexSpec extends AnyWithPropsWithRuntime<\"Convex\">,\n  NodeSpec extends AnyWithPropsWithRuntime<\"Node\">,\n>(\n  convexSpec: ConvexSpec,\n  nodeSpec?: NodeSpec,\n): AnyWithProps => {\n  const groups = Option.fromNullable(nodeSpec).pipe(\n    Option.map((nodeSpec_) =>\n      Array.reduce(\n        Record.toEntries(nodeSpec_.groups),\n        GroupSpec.makeNodeAt(\"node\"),\n        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),\n      ),\n    ),\n    Option.match({\n      onNone: () => convexSpec.groups,\n      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),\n    }),\n  );\n\n  const paths = new Map(convexSpec.paths);\n  if (nodeSpec !== undefined) {\n    for (const [group, path] of nodeSpec.paths) {\n      paths.set(group, `node.${path}`);\n    }\n  }\n\n  return Object.assign(Object.create(Proto), {\n    runtime: \"Convex\" as const,\n    groups,\n    paths,\n  }) as AnyWithProps;\n};\n"],"mappings":";;;;;;;;;;;;;;;AAKA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAElC,MAAa,gBACX,MAEA,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AAEhB,MAAa,cAAc,MACzB,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AA+DhB,MAAM,gBAAgB,SAAuB;AAC3C,KAAI,KAAK,WAAW,EAClB,OAAM,IAAI,MACR,yEACD;CAGH,MAAM,WAAW,OAAO,MAAM,MAAM,IAAI;AAExC,MAAK,MAAM,WAAW,UAAU;AAC9B,MAAI,QAAQ,WAAW,EACrB,OAAM,IAAI,MACR,2FAA2F,KAAK,IACjG;AAEH,oCAAkC,QAAQ;;;AAI9C,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GAClD,OAAO,KAAK;GACb,CAAC;;CAGJ,MAEE,MACA,OACA;AACA,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAMA,SAAmB,MAAM,MAAM,CAAC;GACtE,OAAO,KAAK;GACb,CAAC;;CAGJ,QAA4B,OAA+B,MAAc;AACvE,eAAa,KAAK;EAElB,MAAM,WAAW,KAAK,MAAM,IAAI,MAAM;AACtC,MAAI,aAAa,QAAW;AAC1B,OAAI,aAAa,KACf,QAAO;AAET,SAAM,IAAI,MACR,kEAAkE,SAAS,+BAA+B,KAAK,+CAChH;;EAGH,MAAM,YAAY,IAAI,IAAI,KAAK,MAAM;AACrC,YAAU,IAAI,OAAO,KAAK;AAE1B,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,KAAK;GACb,OAAO;GACR,CAAC;;CAEL;AAED,MAAM,aAGJ,EACA,SACA,QACA,YAMA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACA;CACD,CAAC;AAEJ,MAAM,mCAAgE,IAAI,KAAK;AAE/E,MAAa,aACX,UAAU;CAAE,SAAS;CAAU,QAAQ,EAAE;CAAE,OAAO,YAAY;CAAE,CAAC;AAEnE,MAAa,iBACX,UAAU;CAAE,SAAS;CAAQ,QAAQ,EAAE;CAAE,OAAO,YAAY;CAAE,CAAC;;;;;;;;AASjE,MAAa,SAIX,YACA,aACiB;CACjB,MAAM,SAAS,OAAO,aAAa,SAAS,CAAC,KAC3C,OAAO,KAAK,cACV,MAAM,OACJ,OAAO,UAAU,UAAU,OAAO,EAClCC,WAAqB,OAAO,GAC3B,eAAe,CAAC,MAAM,WAAW,cAAc,WAAW,MAAM,MAAM,CACxE,CACF,EACD,OAAO,MAAM;EACX,cAAc,WAAW;EACzB,SAAS,eAAe;GAAE,GAAG,WAAW;GAAQ,MAAM;GAAW;EAClE,CAAC,CACH;CAED,MAAM,QAAQ,IAAI,IAAI,WAAW,MAAM;AACvC,KAAI,aAAa,OACf,MAAK,MAAM,CAAC,OAAO,SAAS,SAAS,MACnC,OAAM,IAAI,OAAO,QAAQ,OAAO;AAIpC,QAAO,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;EACzC,SAAS;EACT;EACA;EACD,CAAC"}
+{"version":3,"file":"Spec.js","names":["GroupSpec.withName","GroupSpec.makeNodeAt"],"sources":["../src/Spec.ts"],"sourcesContent":["import { Array, Option, Predicate, Record } from \"effect\";\nimport * as GroupSpec from \"./GroupSpec\";\nimport type * as RuntimeAndFunctionType from \"./RuntimeAndFunctionType\";\n\nexport const TypeId = \"@confect/core/Spec\";\nexport type TypeId = typeof TypeId;\n\nexport const isSpec = (u: unknown): u is AnyWithProps =>\n  Predicate.hasProperty(u, TypeId);\n\nexport const isConvexSpec = (\n  u: unknown,\n): u is AnyWithPropsWithRuntime<\"Convex\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Convex\";\n\nexport const isNodeSpec = (u: unknown): u is AnyWithPropsWithRuntime<\"Node\"> =>\n  Predicate.hasProperty(u, TypeId) &&\n  Predicate.hasProperty(u, \"runtime\") &&\n  u.runtime === \"Node\";\n\nexport interface Spec<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime> = never,\n> {\n  readonly [TypeId]: TypeId;\n  readonly runtime: Runtime;\n  readonly groups: {\n    [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<\n      Groups_,\n      GroupName\n    >;\n  };\n\n  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(\n    group: Group,\n  ): Spec<Runtime, Groups_ | Group>;\n\n  addAt<\n    const Name extends string,\n    Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n  >(\n    name: Name,\n    group: Group,\n  ): Spec<Runtime, Groups_ | GroupSpec.NamedAt<Group, Name>>;\n}\n\nexport interface Any {\n  readonly [TypeId]: TypeId;\n}\n\nexport interface AnyWithProps extends Spec<\n  RuntimeAndFunctionType.Runtime,\n  GroupSpec.AnyWithProps\n> {}\n\nexport interface AnyWithPropsWithRuntime<\n  Runtime extends RuntimeAndFunctionType.Runtime,\n> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}\n\nexport type Groups<Spec_ extends AnyWithProps> =\n  Spec_[\"groups\"][keyof Spec_[\"groups\"]];\n\nconst Proto = {\n  [TypeId]: TypeId,\n\n  add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, group.name, group),\n    });\n  },\n\n  addAt<Group extends GroupSpec.AnyWithProps>(\n    this: AnyWithProps,\n    name: string,\n    group: Group,\n  ) {\n    return makeProto({\n      runtime: this.runtime,\n      groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),\n    });\n  },\n};\n\nconst makeProto = <\n  Runtime extends RuntimeAndFunctionType.Runtime,\n  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,\n>({\n  runtime,\n  groups,\n}: {\n  runtime: Runtime;\n  groups: Record.ReadonlyRecord<string, Groups_>;\n}): Spec<Runtime, Groups_> =>\n  Object.assign(Object.create(Proto), {\n    runtime,\n    groups,\n  });\n\nexport const make = (): Spec<\"Convex\"> =>\n  makeProto({ runtime: \"Convex\", groups: {} });\n\nexport const makeNode = (): Spec<\"Node\"> =>\n  makeProto({ runtime: \"Node\", groups: {} });\n\n/**\n * Merges a Convex spec with an optional Node spec into a single assembled\n * spec (used by codegen to build `Refs.make` and to enumerate function paths).\n * When `nodeSpec` is provided, its groups are merged under a \"node\" namespace,\n * mirroring the structure used by `Refs.make`.\n */\nexport const merge = <\n  ConvexSpec extends AnyWithPropsWithRuntime<\"Convex\">,\n  NodeSpec extends AnyWithPropsWithRuntime<\"Node\">,\n>(\n  convexSpec: ConvexSpec,\n  nodeSpec?: NodeSpec,\n): AnyWithProps => {\n  const groups = Option.fromNullable(nodeSpec).pipe(\n    Option.map((nodeSpec_) =>\n      Array.reduce(\n        Record.toEntries(nodeSpec_.groups),\n        GroupSpec.makeNodeAt(\"node\"),\n        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),\n      ),\n    ),\n    Option.match({\n      onNone: () => convexSpec.groups,\n      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),\n    }),\n  );\n\n  return Object.assign(Object.create(Proto), {\n    runtime: \"Convex\" as const,\n    groups,\n  }) as AnyWithProps;\n};\n"],"mappings":";;;;;;;;;;;;;;AAIA,MAAa,SAAS;AAGtB,MAAa,UAAU,MACrB,UAAU,YAAY,GAAG,OAAO;AAElC,MAAa,gBACX,MAEA,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AAEhB,MAAa,cAAc,MACzB,UAAU,YAAY,GAAG,OAAO,IAChC,UAAU,YAAY,GAAG,UAAU,IACnC,EAAE,YAAY;AA4ChB,MAAM,QAAQ;EACX,SAAS;CAEV,IAA8D,OAAc;AAC1E,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAM,MAAM,MAAM;GACnD,CAAC;;CAGJ,MAEE,MACA,OACA;AACA,SAAO,UAAU;GACf,SAAS,KAAK;GACd,QAAQ,OAAO,IAAI,KAAK,QAAQ,MAAMA,SAAmB,MAAM,MAAM,CAAC;GACvE,CAAC;;CAEL;AAED,MAAM,aAGJ,EACA,SACA,aAKA,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;CAClC;CACA;CACD,CAAC;AAEJ,MAAa,aACX,UAAU;CAAE,SAAS;CAAU,QAAQ,EAAE;CAAE,CAAC;AAE9C,MAAa,iBACX,UAAU;CAAE,SAAS;CAAQ,QAAQ,EAAE;CAAE,CAAC;;;;;;;AAQ5C,MAAa,SAIX,YACA,aACiB;CACjB,MAAM,SAAS,OAAO,aAAa,SAAS,CAAC,KAC3C,OAAO,KAAK,cACV,MAAM,OACJ,OAAO,UAAU,UAAU,OAAO,EAClCC,WAAqB,OAAO,GAC3B,eAAe,CAAC,MAAM,WAAW,cAAc,WAAW,MAAM,MAAM,CACxE,CACF,EACD,OAAO,MAAM;EACX,cAAc,WAAW;EACzB,SAAS,eAAe;GAAE,GAAG,WAAW;GAAQ,MAAM;GAAW;EAClE,CAAC,CACH;AAED,QAAO,OAAO,OAAO,OAAO,OAAO,MAAM,EAAE;EACzC,SAAS;EACT;EACD,CAAC"}

package/dist/index.d.ts

@@ -4,6 +4,8 @@ import { FunctionSpec_d_exports } from "./FunctionSpec.js";
 import { GenericId_d_exports } from "./GenericId.js";
 import { GroupSpec_d_exports } from "./GroupSpec.js";
 import { GroupPath_d_exports } from "./GroupPath.js";
+import { Identifier_d_exports } from "./Identifier.js";
+import { Lazy_d_exports } from "./Lazy.js";
 import { PaginationResult_d_exports } from "./PaginationResult.js";
 import { Ref_d_exports } from "./Ref.js";
 import { Spec_d_exports } from "./Spec.js";
@@ -12,4 +14,4 @@ import { Registry_d_exports } from "./Registry.js";
 import { SystemFields_d_exports } from "./SystemFields.js";
 import { Types_d_exports } from "./Types.js";
 import { UserIdentity_d_exports } from "./UserIdentity.js";
-export { FunctionProvenance_d_exports as FunctionProvenance, FunctionSpec_d_exports as FunctionSpec, GenericId_d_exports as GenericId, GroupPath_d_exports as GroupPath, GroupSpec_d_exports as GroupSpec, PaginationResult_d_exports as PaginationResult, Ref_d_exports as Ref, Refs_d_exports as Refs, Registry_d_exports as Registry, RuntimeAndFunctionType_d_exports as RuntimeAndFunctionType, Spec_d_exports as Spec, SystemFields_d_exports as SystemFields, Types_d_exports as Types, UserIdentity_d_exports as UserIdentity };
+export { FunctionProvenance_d_exports as FunctionProvenance, FunctionSpec_d_exports as FunctionSpec, GenericId_d_exports as GenericId, GroupPath_d_exports as GroupPath, GroupSpec_d_exports as GroupSpec, Identifier_d_exports as Identifier, Lazy_d_exports as Lazy, PaginationResult_d_exports as PaginationResult, Ref_d_exports as Ref, Refs_d_exports as Refs, Registry_d_exports as Registry, RuntimeAndFunctionType_d_exports as RuntimeAndFunctionType, Spec_d_exports as Spec, SystemFields_d_exports as SystemFields, Types_d_exports as Types, UserIdentity_d_exports as UserIdentity };

package/dist/index.js

@@ -1,4 +1,6 @@
+import { Lazy_exports } from "./Lazy.js";
 import { FunctionProvenance_exports } from "./FunctionProvenance.js";
+import { Identifier_exports } from "./Identifier.js";
 import { RuntimeAndFunctionType_exports } from "./RuntimeAndFunctionType.js";
 import { FunctionSpec_exports } from "./FunctionSpec.js";
 import { GenericId_exports } from "./GenericId.js";
@@ -13,4 +15,4 @@ import { SystemFields_exports } from "./SystemFields.js";
 import { Types_exports } from "./Types.js";
 import { UserIdentity_exports } from "./UserIdentity.js";
 
-export { FunctionProvenance_exports as FunctionProvenance, FunctionSpec_exports as FunctionSpec, GenericId_exports as GenericId, GroupPath_exports as GroupPath, GroupSpec_exports as GroupSpec, PaginationResult_exports as PaginationResult, Ref_exports as Ref, Refs_exports as Refs, Registry_exports as Registry, RuntimeAndFunctionType_exports as RuntimeAndFunctionType, Spec_exports as Spec, SystemFields_exports as SystemFields, Types_exports as Types, UserIdentity_exports as UserIdentity };
+export { FunctionProvenance_exports as FunctionProvenance, FunctionSpec_exports as FunctionSpec, GenericId_exports as GenericId, GroupPath_exports as GroupPath, GroupSpec_exports as GroupSpec, Identifier_exports as Identifier, Lazy_exports as Lazy, PaginationResult_exports as PaginationResult, Ref_exports as Ref, Refs_exports as Refs, Registry_exports as Registry, RuntimeAndFunctionType_exports as RuntimeAndFunctionType, Spec_exports as Spec, SystemFields_exports as SystemFields, Types_exports as Types, UserIdentity_exports as UserIdentity };

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "@confect/core",
-  "version": "9.0.0-next.5",
   "description": "Shared specs and schemas used by all Confect packages",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rjdellecese/confect.git"
-  },
+  "version": "9.0.0-next.6",
+  "author": "RJ Dellecese",
   "bugs": {
     "url": "https://github.com/rjdellecese/confect/issues"
   },
-  "homepage": "https://confect.dev",
-  "sideEffects": false,
-  "type": "module",
-  "files": [
-    "CHANGELOG.md",
-    "LICENSE",
-    "README.md",
-    "dist",
-    "package.json",
-    "src"
-  ],
+  "devDependencies": {
+    "@ark/attest": "0.56.0",
+    "@effect/vitest": "0.29.0",
+    "@eslint/js": "10.0.1",
+    "@types/node": "25.3.3",
+    "effect": "3.21.2",
+    "eslint": "10.0.2",
+    "prettier": "3.8.1",
+    "tsdown": "0.20.3",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.56.1",
+    "vitest": "3.2.4"
+  },
+  "engines": {
+    "node": ">=22"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -32,46 +35,42 @@
     "./package.json": "./package.json",
     "./internal/*": null
   },
+  "files": [
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "dist",
+    "package.json",
+    "src"
+  ],
+  "homepage": "https://confect.dev",
   "keywords": [
-    "effect",
-    "convex"
+    "convex",
+    "effect"
   ],
-  "author": "RJ Dellecese",
   "license": "ISC",
-  "devDependencies": {
-    "@ark/attest": "0.56.0",
-    "@effect/vitest": "0.29.0",
-    "@eslint/js": "10.0.1",
-    "@types/node": "25.3.3",
-    "effect": "3.21.2",
-    "eslint": "10.0.2",
-    "prettier": "3.8.1",
-    "tsdown": "0.20.3",
-    "tsx": "4.21.0",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.56.1",
-    "vitest": "3.2.4"
-  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "peerDependencies": {
     "convex": "1.39.1",
     "effect": "^3.21.2"
   },
-  "engines": {
-    "node": ">=22",
-    "pnpm": ">=10"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rjdellecese/confect.git"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "sideEffects": false,
+  "type": "module",
   "types": "./dist/index.d.ts",
   "scripts": {
+    "bench": "tsx test/Refs.bench.ts",
     "build": "tsdown --config-loader unrun",
+    "clean": "rm -rf dist coverage node_modules",
     "dev": "tsdown --watch",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit --project tsconfig.json",
     "fix": "prettier --write . && eslint --fix . --max-warnings=0",
     "format": "prettier --check .",
     "lint": "eslint . --max-warnings=0",
-    "bench": "tsx test/Refs.bench.ts",
-    "clean": "rm -rf dist coverage node_modules"
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit --project tsconfig.json"
   }
 }

package/src/FunctionProvenance.ts

@@ -1,6 +1,7 @@
 import type { DefaultFunctionArgs } from "convex/server";
 import type { Schema } from "effect";
 import { Data } from "effect";
+import * as Lazy from "./Lazy";
 
 export type FunctionProvenance = Data.TaggedEnum<{
   Confect: {
@@ -43,20 +44,41 @@ export interface AnyConvex extends Convex<DefaultFunctionArgs, any> {}
 
 export const FunctionProvenance = Data.taggedEnum<FunctionProvenance>();
 
+/**
+ * Build a `Confect` provenance from lazy schema thunks. `args`, `returns`,
+ * and `error` are exposed as sync lazy memoised getters (via {@link Lazy.defineProperty})
+ * that only evaluate their thunk on first access, mirroring how `Table`
+ * defers `Fields`/`Doc`/`tableDefinition`. This keeps importing the assembled
+ * `_generated/spec.ts` cheap — no `Schema.Struct(...)` / `Schema.Array(...)`
+ * work runs at module load; it is deferred to the first invocation that
+ * actually compiles validators or runs a codec.
+ *
+ * The object is built by hand rather than through `FunctionProvenance.Confect`
+ * because the `Data` constructor copies its input with `Object.assign`, which
+ * would force the getters at construction time and defeat the laziness.
+ * `error` is only installed when an `errorThunk` is provided, so its absence
+ * is observable via `"error" in provenance` without forcing anything; nothing
+ * relies on `Data`'s structural `Equal`/`Hash` for provenance values.
+ */
 export const Confect = <
   Args extends Schema.Schema.AnyNoContext,
   Returns extends Schema.Schema.AnyNoContext,
   Error extends Schema.Schema.AnyNoContext = never,
 >(
-  args: Args,
-  returns: Returns,
-  error?: Error,
-) =>
-  FunctionProvenance.Confect({
-    args,
-    returns,
-    ...(error !== undefined ? { error } : {}),
-  });
+  args: () => Args,
+  returns: () => Returns,
+  error?: () => Error,
+): Confect<Args, Returns, Error> => {
+  const provenance = { _tag: "Confect" as const };
+
+  Lazy.defineProperty(provenance, "args", args);
+  Lazy.defineProperty(provenance, "returns", returns);
+  if (error !== undefined) {
+    Lazy.defineProperty(provenance, "error", error);
+  }
+
+  return provenance as Confect<Args, Returns, Error>;
+};
 
 export const Convex = <_Args extends DefaultFunctionArgs, _Returns>() =>
   FunctionProvenance.Convex(

package/src/FunctionSpec.ts

@@ -8,7 +8,7 @@ import type {
 import type { Schema } from "effect";
 import { Predicate } from "effect";
 import * as FunctionProvenance from "./FunctionProvenance";
-import { validateConfectFunctionIdentifier } from "./internal/utils";
+import { validateConfectFunctionIdentifier } from "./Identifier";
 import * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export const TypeId = "@confect/core/FunctionSpec";
@@ -225,9 +225,9 @@ const make =
     error,
   }: {
     name: Name_;
-    args: Args_;
-    returns: Returns_;
-    error?: Error_;
+    args: () => Args_;
+    returns: () => Returns_;
+    error?: () => Error_;
   }): FunctionSpec<
     RuntimeAndFunctionType_,
     FunctionVisibility_,

package/src/GroupSpec.ts

@@ -1,7 +1,7 @@
 import { Predicate, Record } from "effect";
 import type * as FunctionSpec from "./FunctionSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
-import { validateConfectFunctionIdentifier } from "./internal/utils";
+import { validateConfectFunctionIdentifier } from "./Identifier";
 
 export const TypeId = "@confect/core/GroupSpec";
 export type TypeId = typeof TypeId;