@confect/core 9.0.0-next.0 → 9.0.0-next.10

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 Data from "effect/Data";
+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

@@ -6,9 +6,9 @@ import type {
   RegisteredQuery,
 } from "convex/server";
 import type { Schema } from "effect";
-import { Predicate } from "effect";
+import * as Predicate from "effect/Predicate";
 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/GenericId.ts

@@ -1,5 +1,7 @@
 import type { GenericId as ConvexGenericId } from "convex/values";
-import { type Option, Schema, SchemaAST } from "effect";
+import type { Option } from "effect";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
 
 const ConvexId = Symbol.for("ConvexId");
 

package/src/GroupSpec.ts

@@ -1,7 +1,8 @@
-import { Predicate, Record } from "effect";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 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;
@@ -13,7 +14,11 @@ export interface GroupSpec<
   Runtime extends RuntimeAndFunctionType.Runtime,
   Name_ extends string,
   Functions_ extends FunctionSpec.AnyWithPropsWithRuntime<Runtime> = never,
-  Groups_ extends AnyWithPropsWithRuntime<Runtime> = never,
+  // Subgroups may be of any runtime, independent of this group's own runtime: a
+  // group is only a namespace for its children, which are otherwise-independent
+  // modules. Functions, by contrast, stay homogeneous (a Node group only accepts
+  // Node actions) — `addFunction` keeps the `<Runtime>` bound below.
+  Groups_ extends AnyWithProps = never,
 > {
   readonly [TypeId]: TypeId;
   readonly runtime: Runtime;
@@ -31,14 +36,11 @@ export interface GroupSpec<
     function_: Function,
   ): GroupSpec<Runtime, Name_, Functions_ | Function, Groups_>;
 
-  addGroup<Group extends AnyWithPropsWithRuntime<Runtime>>(
+  addGroup<Group extends AnyWithProps>(
     group: Group,
   ): GroupSpec<Runtime, Name_, Functions_, Groups_ | Group>;
 
-  addGroupAt<
-    const AtName extends string,
-    Group extends AnyWithPropsWithRuntime<Runtime>,
-  >(
+  addGroupAt<const AtName extends string, Group extends AnyWithProps>(
     name: AtName,
     group: Group,
   ): GroupSpec<Runtime, Name_, Functions_, Groups_ | NamedAt<Group, AtName>>;
@@ -209,7 +211,10 @@ export const withName = <const Name_ extends string>(
     return group_;
   }
 
-  // Keep object identity so impls can pass the same GroupSpec instance
-  // imported from a sibling `.spec.ts` into `resolveGroupPath`.
-  return Object.assign(group_, { name }) as AnyWithProps;
+  return makeProto({
+    runtime: group_.runtime,
+    name,
+    functions: group_.functions,
+    groups: group_.groups,
+  });
 };

package/src/{internal/utils.ts → Identifier.ts}

@@ -56,6 +56,12 @@ const RESERVED_CONVEX_FILE_NAMES = new Set(["schema", "http", "crons"]);
 
 const jsIdentifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 
+// Stricter than `jsIdentifierRegex`: tables cannot start with `_` (Convex
+// reserves leading underscores for system tables) or `$` (Convex's table
+// naming grammar does not accept it). Letters/digits/underscore only,
+// letter-leading.
+const tableNameRegex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
 const isReservedJsIdentifier = (identifier: string) =>
   RESERVED_JS_IDENTIFIERS.has(identifier);
 
@@ -65,6 +71,9 @@ const isReservedConvexFileName = (fileName: string) =>
 const matchesJsIdentifierPattern = (identifier: string) =>
   jsIdentifierRegex.test(identifier);
 
+const matchesTableNamePattern = (identifier: string) =>
+  tableNameRegex.test(identifier);
+
 export const validateConfectFunctionIdentifier = (identifier: string) => {
   if (!matchesJsIdentifierPattern(identifier)) {
     throw new Error(
@@ -84,3 +93,28 @@ export const validateConfectFunctionIdentifier = (identifier: string) => {
     );
   }
 };
+
+/**
+ * Validate that `identifier` is suitable as a Convex table name (and, equivalently,
+ * as a `confect/tables/<identifier>.ts` filename).
+ *
+ * Rules:
+ * - Must match `/^[A-Za-z][A-Za-z0-9_]*$/` — letter-leading, alphanumeric plus
+ *   underscore. No `$` (not a valid Convex table name character); no leading
+ *   `_` (Convex reserves `_<name>` for its system tables).
+ * - Must not be a reserved JavaScript identifier, so the name can also be used
+ *   as a binding name in generated code without escaping.
+ */
+export const validateConfectTableIdentifier = (identifier: string) => {
+  if (!matchesTableNamePattern(identifier)) {
+    throw new Error(
+      `Expected a valid Confect table identifier, but received: "${identifier}". Valid table identifiers must start with a letter and can only contain letters, numbers, and underscores. Leading underscores are reserved for Convex system tables.`,
+    );
+  }
+
+  if (isReservedJsIdentifier(identifier)) {
+    throw new Error(
+      `Expected a valid Confect table identifier, but received: "${identifier}". "${identifier}" is a reserved JavaScript identifier.`,
+    );
+  }
+};

package/src/Lazy.ts

@@ -0,0 +1,40 @@
+/**
+ * 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.
+ */
+export const defineProperty = <T extends object, K extends PropertyKey>(
+  target: T,
+  key: K,
+  compute: () => unknown,
+): void => {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    get(this: T) {
+      const value = compute();
+      Object.defineProperty(this, key, {
+        value,
+        writable: false,
+        enumerable: true,
+        configurable: false,
+      });
+      return value;
+    },
+  });
+};

package/src/PaginationResult.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 export const PaginationResult = <Doc extends Schema.Schema.AnyNoContext>(
   Doc: Doc,

package/src/Ref.ts

@@ -6,7 +6,10 @@ import { makeFunctionReference } from "convex/server";
 import type { Value } from "convex/values";
 import { ConvexError } from "convex/values";
 import type { ParseResult } from "effect";
-import { Effect, Match, Option, Schema } from "effect";
+import * as Effect from "effect/Effect";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 import type * as FunctionSpec from "./FunctionSpec";
 import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
@@ -190,17 +193,29 @@ export const make = <FunctionSpec_ extends FunctionSpec.AnyWithProps>(
 export const getConvexFunctionName = (ref: Any): string =>
   `${ref.functionNamespace}:${ref.functionSpec.name}`;
 
+const functionReferenceCache = new Map<string, FunctionReference<Any>>();
+
 export const getFunctionReference = <Ref_ extends Any>(
   ref: Ref_,
-): FunctionReference<Ref_> =>
-  makeFunctionReference(getConvexFunctionName(ref)) as FunctionReference<Ref_>;
+): FunctionReference<Ref_> => {
+  const functionName = getConvexFunctionName(ref);
+
+  const cached = functionReferenceCache.get(functionName);
+  if (cached !== undefined) {
+    return cached as FunctionReference<Ref_>;
+  }
+
+  const functionReference = makeFunctionReference(functionName);
+  functionReferenceCache.set(functionName, functionReference);
+
+  return functionReference as FunctionReference<Ref_>;
+};
 
 export const hasErrorSchema = (ref: Any): boolean =>
   Match.value(ref.functionSpec.functionProvenance).pipe(
     Match.tag(
       "Confect",
-      (confectFunctionProvenance) =>
-        confectFunctionProvenance.error !== undefined,
+      (confectFunctionProvenance) => "error" in confectFunctionProvenance,
     ),
     Match.tag("Convex", () => false),
     Match.exhaustive,
@@ -296,7 +311,7 @@ export const decodeError = <Ref_ extends Any>(
 ): Effect.Effect<Option.Option<Error<Ref_>>, ParseResult.ParseError> =>
   Match.value(ref.functionSpec.functionProvenance).pipe(
     Match.tag("Confect", (confectFunctionProvenance) =>
-      confectFunctionProvenance.error !== undefined
+      "error" in confectFunctionProvenance
         ? Effect.map(
             Schema.decode(confectFunctionProvenance.error)(encodedError),
             Option.some,
@@ -317,7 +332,7 @@ export const decodeErrorSync = <Ref_ extends Any>(
 ): Option.Option<Error<Ref_>> =>
   Match.value(ref.functionSpec.functionProvenance).pipe(
     Match.tag("Confect", (confectFunctionProvenance) =>
-      confectFunctionProvenance.error !== undefined
+      "error" in confectFunctionProvenance
         ? Option.some(
             Schema.decodeSync(confectFunctionProvenance.error)(
               encodedError,
@@ -336,7 +351,7 @@ export const maybeDecodeErrorSync = <Ref_ extends Any>(
   isConvexError(error)
     ? Match.value(ref.functionSpec.functionProvenance).pipe(
         Match.tag("Confect", (confectFunctionProvenance) =>
-          confectFunctionProvenance.error !== undefined
+          "error" in confectFunctionProvenance
             ? Schema.decodeSync(confectFunctionProvenance.error)(error.data)
             : error,
         ),

package/src/Refs.ts

@@ -1,30 +1,16 @@
 import type { Types } from "effect";
-import { Array, Option, pipe, Record } from "effect";
+import { pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Record from "effect/Record";
 import type * as FunctionSpec from "./FunctionSpec";
-import * as GroupSpec from "./GroupSpec";
+import type * as GroupSpec from "./GroupSpec";
 import * as Ref from "./Ref";
 import type * as Spec from "./Spec";
 
 export type Refs<
-  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
+  Spec_ extends Spec.AnyWithProps,
   Predicate extends Ref.Any = Ref.Any,
-> = Types.Simplify<
-  OmitEmpty<
-    Helper<
-      | Spec.Groups<ConvexSpec>
-      | (NodeSpec extends never
-          ? never
-          : GroupSpec.GroupSpec<
-              "Node",
-              "node",
-              never,
-              NodeSpec["groups"][keyof NodeSpec["groups"]]
-            >),
-      Predicate
-    >
-  >
->;
+> = Types.Simplify<OmitEmpty<Helper<Spec.Groups<Spec_>, Predicate>>>;
 
 type GroupRefs<
   Group extends GroupSpec.AnyWithProps,
@@ -86,33 +72,16 @@ type Any =
     }
   | Ref.Any;
 
-export const make = <
-  ConvexSpec extends Spec.AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends Spec.AnyWithPropsWithRuntime<"Node"> = never,
->(
-  convexSpec: ConvexSpec,
-  nodeSpec?: NodeSpec,
+export const make = <Spec_ extends Spec.AnyWithProps>(
+  spec: Spec_,
 ): {
-  public: Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>;
-  internal: Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>;
+  public: Refs<Spec_, Ref.AnyPublic>;
+  internal: Refs<Spec_, Ref.AnyInternal>;
 } => {
-  const groups = Option.fromNullable(nodeSpec).pipe(
-    Option.map((nodeSpec_) =>
-      Array.reduce(
-        Record.toEntries(nodeSpec_.groups),
-        GroupSpec.makeNodeAt("node"),
-        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),
-      ),
-    ),
-    Option.match({
-      onNone: () => convexSpec.groups,
-      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),
-    }),
-  );
-  const refs = makeHelper(groups);
+  const refs = makeHelper(spec.groups);
   return {
-    public: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyPublic>,
-    internal: refs as Refs<ConvexSpec, NodeSpec, Ref.AnyInternal>,
+    public: refs as Refs<Spec_, Ref.AnyPublic>,
+    internal: refs as Refs<Spec_, Ref.AnyInternal>,
   };
 };
 

package/src/Registry.ts

@@ -1,4 +1,5 @@
-import { Context, Ref } from "effect";
+import * as Context from "effect/Context";
+import * as Ref from "effect/Ref";
 
 /**
  * Recursive tree that mirrors a `Spec`'s group structure. Leaves are the

package/src/Spec.ts

@@ -1,6 +1,6 @@
-import { Array, Option, Predicate, Record } from "effect";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
 import * as GroupSpec from "./GroupSpec";
-import type * as RuntimeAndFunctionType from "./RuntimeAndFunctionType";
 
 export const TypeId = "@confect/core/Spec";
 export type TypeId = typeof TypeId;
@@ -8,24 +8,15 @@ export type TypeId = typeof TypeId;
 export const isSpec = (u: unknown): u is AnyWithProps =>
   Predicate.hasProperty(u, TypeId);
 
-export const isConvexSpec = (
-  u: unknown,
-): u is AnyWithPropsWithRuntime<"Convex"> =>
-  Predicate.hasProperty(u, TypeId) &&
-  Predicate.hasProperty(u, "runtime") &&
-  u.runtime === "Convex";
-
-export const isNodeSpec = (u: unknown): u is AnyWithPropsWithRuntime<"Node"> =>
-  Predicate.hasProperty(u, TypeId) &&
-  Predicate.hasProperty(u, "runtime") &&
-  u.runtime === "Node";
-
-export interface Spec<
-  Runtime extends RuntimeAndFunctionType.Runtime,
-  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime> = never,
-> {
+/**
+ * A Confect spec: a flat container of function groups. Groups may be of any
+ * runtime — a group built with `GroupSpec.makeNode()` (a Node action group) sits
+ * alongside `GroupSpec.make()` groups in the same namespace. The runtime of a
+ * group lives on the group itself (`GroupSpec.runtime`) and on each function's
+ * `RuntimeAndFunctionType`; the spec does not carry a runtime of its own.
+ */
+export interface Spec<Groups_ extends GroupSpec.AnyWithProps = never> {
   readonly [TypeId]: TypeId;
-  readonly runtime: Runtime;
   readonly groups: {
     [GroupName in GroupSpec.Name<Groups_>]: GroupSpec.WithName<
       Groups_,
@@ -33,31 +24,21 @@ export interface Spec<
     >;
   };
 
-  add<Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>>(
+  add<Group extends GroupSpec.AnyWithProps>(
     group: Group,
-  ): Spec<Runtime, Groups_ | Group>;
+  ): Spec<Groups_ | Group>;
 
-  addAt<
-    const Name extends string,
-    Group extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,
-  >(
+  addAt<const Name extends string, Group extends GroupSpec.AnyWithProps>(
     name: Name,
     group: Group,
-  ): Spec<Runtime, Groups_ | GroupSpec.NamedAt<Group, Name>>;
+  ): Spec<Groups_ | GroupSpec.NamedAt<Group, Name>>;
 }
 
 export interface Any {
   readonly [TypeId]: TypeId;
 }
 
-export interface AnyWithProps extends Spec<
-  RuntimeAndFunctionType.Runtime,
-  GroupSpec.AnyWithProps
-> {}
-
-export interface AnyWithPropsWithRuntime<
-  Runtime extends RuntimeAndFunctionType.Runtime,
-> extends Spec<Runtime, GroupSpec.AnyWithPropsWithRuntime<Runtime>> {}
+export interface AnyWithProps extends Spec<GroupSpec.AnyWithProps> {}
 
 export type Groups<Spec_ extends AnyWithProps> =
   Spec_["groups"][keyof Spec_["groups"]];
@@ -67,7 +48,6 @@ const Proto = {
 
   add<Group extends GroupSpec.AnyWithProps>(this: AnyWithProps, group: Group) {
     return makeProto({
-      runtime: this.runtime,
       groups: Record.set(this.groups, group.name, group),
     });
   },
@@ -78,61 +58,18 @@ const Proto = {
     group: Group,
   ) {
     return makeProto({
-      runtime: this.runtime,
       groups: Record.set(this.groups, name, GroupSpec.withName(name, group)),
     });
   },
 };
 
-const makeProto = <
-  Runtime extends RuntimeAndFunctionType.Runtime,
-  Groups_ extends GroupSpec.AnyWithPropsWithRuntime<Runtime>,
->({
-  runtime,
+const makeProto = <Groups_ extends GroupSpec.AnyWithProps>({
   groups,
 }: {
-  runtime: Runtime;
   groups: Record.ReadonlyRecord<string, Groups_>;
-}): Spec<Runtime, Groups_> =>
+}): Spec<Groups_> =>
   Object.assign(Object.create(Proto), {
-    runtime,
     groups,
   });
 
-export const make = (): Spec<"Convex"> =>
-  makeProto({ runtime: "Convex", groups: {} });
-
-export const makeNode = (): Spec<"Node"> =>
-  makeProto({ runtime: "Node", groups: {} });
-
-/**
- * Merges a Convex spec with an optional Node spec for use with `Api.make`.
- * When `nodeSpec` is provided, its groups are merged under a "node" namespace,
- * mirroring the structure used by `Refs.make`.
- */
-export const merge = <
-  ConvexSpec extends AnyWithPropsWithRuntime<"Convex">,
-  NodeSpec extends AnyWithPropsWithRuntime<"Node">,
->(
-  convexSpec: ConvexSpec,
-  nodeSpec?: NodeSpec,
-): AnyWithProps => {
-  const groups = Option.fromNullable(nodeSpec).pipe(
-    Option.map((nodeSpec_) =>
-      Array.reduce(
-        Record.toEntries(nodeSpec_.groups),
-        GroupSpec.makeNodeAt("node"),
-        (nodeGroupSpec, [name, group]) => nodeGroupSpec.addGroupAt(name, group),
-      ),
-    ),
-    Option.match({
-      onNone: () => convexSpec.groups,
-      onSome: (nodeGroup) => ({ ...convexSpec.groups, node: nodeGroup }),
-    }),
-  );
-
-  return Object.assign(Object.create(Proto), {
-    runtime: "Convex" as const,
-    groups,
-  }) as AnyWithProps;
-};
+export const make = (): Spec => makeProto({ groups: {} });

package/src/SystemFields.ts

@@ -3,7 +3,7 @@ import type {
   IdField,
   SystemFields as NonIdSystemFields,
 } from "convex/server";
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 import * as GenericId from "./GenericId";
 
 type SystemFieldsSchema<TableName extends string> = Schema.Struct<{

package/src/UserIdentity.ts

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 
 export const UserIdentity = <CustomClaimsFields extends Schema.Struct.Fields>(
   customClaimsFields: CustomClaimsFields,

package/src/index.ts

@@ -3,6 +3,8 @@ export * as FunctionSpec from "./FunctionSpec";
 export * as GenericId from "./GenericId";
 export * as GroupPath from "./GroupPath";
 export * as GroupSpec from "./GroupSpec";
+export * as Identifier from "./Identifier";
+export * as Lazy from "./Lazy";
 export * as PaginationResult from "./PaginationResult";
 export * as Ref from "./Ref";
 export * as Refs from "./Refs";

package/dist/internal/utils.d.ts

@@ -1,5 +0,0 @@
-//#region src/internal/utils.d.ts
-declare const validateConfectFunctionIdentifier: (identifier: string) => void;
-//#endregion
-export { validateConfectFunctionIdentifier };
-//# sourceMappingURL=utils.d.ts.map

package/dist/internal/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/internal/utils.ts"],"mappings":";cAmEa,iCAAA,GAAqC,UAAA"}

package/dist/internal/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","names":[],"sources":["../../src/internal/utils.ts"],"sourcesContent":["const RESERVED_JS_IDENTIFIERS = new Set([\n  // Reserved keywords\n  \"break\",\n  \"case\",\n  \"catch\",\n  \"class\",\n  \"const\",\n  \"continue\",\n  \"debugger\",\n  \"default\",\n  \"delete\",\n  \"do\",\n  \"else\",\n  \"export\",\n  \"extends\",\n  \"finally\",\n  \"for\",\n  \"function\",\n  \"if\",\n  \"import\",\n  \"in\",\n  \"instanceof\",\n  \"new\",\n  \"return\",\n  \"super\",\n  \"switch\",\n  \"this\",\n  \"throw\",\n  \"try\",\n  \"typeof\",\n  \"var\",\n  \"void\",\n  \"while\",\n  \"with\",\n  \"yield\",\n  // Future reserved keywords\n  \"await\",\n  \"enum\",\n  \"implements\",\n  \"interface\",\n  \"let\",\n  \"package\",\n  \"private\",\n  \"protected\",\n  \"public\",\n  \"static\",\n  // Literal values that cannot be reassigned\n  \"null\",\n  \"true\",\n  \"false\",\n  // Global objects that shouldn't be shadowed\n  \"undefined\",\n]);\n\nconst RESERVED_CONVEX_FILE_NAMES = new Set([\"schema\", \"http\", \"crons\"]);\n\nconst jsIdentifierRegex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;\n\nconst isReservedJsIdentifier = (identifier: string) =>\n  RESERVED_JS_IDENTIFIERS.has(identifier);\n\nconst isReservedConvexFileName = (fileName: string) =>\n  RESERVED_CONVEX_FILE_NAMES.has(fileName);\n\nconst matchesJsIdentifierPattern = (identifier: string) =>\n  jsIdentifierRegex.test(identifier);\n\nexport const validateConfectFunctionIdentifier = (identifier: string) => {\n  if (!matchesJsIdentifierPattern(identifier)) {\n    throw new Error(\n      `Expected a valid Confect function identifier, but received: \"${identifier}\". Valid identifiers must start with a letter, underscore, or dollar sign, and can only contain letters, numbers, underscores, or dollar signs.`,\n    );\n  }\n\n  if (isReservedJsIdentifier(identifier)) {\n    throw new Error(\n      `Expected a valid Confect function identifier, but received: \"${identifier}\". \"${identifier}\" is a reserved JavaScript identifier.`,\n    );\n  }\n\n  if (isReservedConvexFileName(identifier)) {\n    throw new Error(\n      `Expected a valid Confect function identifier, but received: \"${identifier}\". \"${identifier}\" is a reserved Convex file name.`,\n    );\n  }\n};\n"],"mappings":";AAAA,MAAM,0BAA0B,IAAI,IAAI;CAEtC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA;CACA;CACA;CAEA;CACD,CAAC;AAEF,MAAM,6BAA6B,IAAI,IAAI;CAAC;CAAU;CAAQ;CAAQ,CAAC;AAEvE,MAAM,oBAAoB;AAE1B,MAAM,0BAA0B,eAC9B,wBAAwB,IAAI,WAAW;AAEzC,MAAM,4BAA4B,aAChC,2BAA2B,IAAI,SAAS;AAE1C,MAAM,8BAA8B,eAClC,kBAAkB,KAAK,WAAW;AAEpC,MAAa,qCAAqC,eAAuB;AACvE,KAAI,CAAC,2BAA2B,WAAW,CACzC,OAAM,IAAI,MACR,gEAAgE,WAAW,iJAC5E;AAGH,KAAI,uBAAuB,WAAW,CACpC,OAAM,IAAI,MACR,gEAAgE,WAAW,MAAM,WAAW,wCAC7F;AAGH,KAAI,yBAAyB,WAAW,CACtC,OAAM,IAAI,MACR,gEAAgE,WAAW,MAAM,WAAW,mCAC7F"}