syncorejs 0.1.0

package/dist/_vendor/core/runtime/functions.d.mts

@@ -0,0 +1,123 @@
+import { Infer, Validator, ValidatorMap } from "../../schema/index.d.ts";
+
+//#region src/runtime/functions.d.ts
+type SyncoreFunctionKind = "query" | "mutation" | "action";
+type EmptyArgs = Record<never, never>;
+/**
+ * A typed reference to a Syncore function.
+ *
+ * Most app code gets these references from the generated `api` object.
+ */
+interface FunctionReference<TKind extends SyncoreFunctionKind = SyncoreFunctionKind, TArgs = EmptyArgs, TResult = unknown> {
+  kind: TKind;
+  name: string;
+  readonly __args?: TArgs;
+  readonly __result?: TResult;
+}
+interface SyncoreFunctionDefinition<TKind extends SyncoreFunctionKind, TContext, TArgs, TResult> {
+  kind: TKind;
+  argsValidator: Validator<TArgs>;
+  returnsValidator?: Validator<TResult>;
+  handler: (ctx: TContext, args: TArgs) => Promise<TResult> | TResult;
+}
+type FunctionArgs<TReference> = TReference extends FunctionReference<SyncoreFunctionKind, infer TArgs, unknown> ? TArgs : never;
+type FunctionResult<TReference> = TReference extends FunctionReference<SyncoreFunctionKind, unknown, infer TResult> ? TResult : never;
+type FunctionKindFromDefinition<TDefinition> = TDefinition extends {
+  kind: infer TKind;
+} ? Extract<TKind, SyncoreFunctionKind> : never;
+type FunctionArgsFromDefinition<TDefinition> = TDefinition extends {
+  argsValidator: Validator<infer TArgs>;
+} ? TArgs : never;
+type FunctionResultFromDefinition<TDefinition> = TDefinition extends {
+  returnsValidator?: Validator<infer TResult>;
+} ? TResult : never;
+type FunctionReferenceFor<TDefinition> = FunctionKindFromDefinition<TDefinition> extends never ? never : FunctionReference<FunctionKindFromDefinition<TDefinition>, FunctionArgsFromDefinition<TDefinition>, FunctionResultFromDefinition<TDefinition>>;
+interface FunctionConfig<TContext, TArgs, TResult> {
+  args: Validator<TArgs> | ValidatorMap;
+  returns?: Validator<TResult>;
+  handler: (ctx: TContext, args: TArgs) => Promise<TResult> | TResult;
+}
+type InferArgs<TArgs extends Validator<unknown> | ValidatorMap> = TArgs extends Validator<unknown> ? Infer<TArgs> : TArgs extends ValidatorMap ? { [TKey in keyof TArgs]: Infer<TArgs[TKey]> } : never;
+/**
+ * Define a Syncore query.
+ *
+ * Queries can read local Syncore state and are available to clients.
+ */
+declare function query<TContext = unknown, TValidator extends Validator<unknown> = Validator<unknown>, TResult = unknown>(config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {
+  args: TValidator;
+}): SyncoreFunctionDefinition<"query", TContext, Infer<TValidator>, TResult>;
+declare function query<TContext = unknown, TArgsShape extends ValidatorMap = ValidatorMap, TResult = unknown>(config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {
+  args: TArgsShape;
+}): SyncoreFunctionDefinition<"query", TContext, InferArgs<TArgsShape>, TResult>;
+/**
+ * Define a Syncore mutation.
+ *
+ * Mutations can modify local Syncore state and are available to clients.
+ */
+declare function mutation<TContext = unknown, TValidator extends Validator<unknown> = Validator<unknown>, TResult = unknown>(config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {
+  args: TValidator;
+}): SyncoreFunctionDefinition<"mutation", TContext, Infer<TValidator>, TResult>;
+declare function mutation<TContext = unknown, TArgsShape extends ValidatorMap = ValidatorMap, TResult = unknown>(config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {
+  args: TArgsShape;
+}): SyncoreFunctionDefinition<"mutation", TContext, InferArgs<TArgsShape>, TResult>;
+/**
+ * Define a Syncore action.
+ *
+ * Actions can run arbitrary JavaScript and may call other Syncore functions.
+ */
+declare function action<TContext = unknown, TValidator extends Validator<unknown> = Validator<unknown>, TResult = unknown>(config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {
+  args: TValidator;
+}): SyncoreFunctionDefinition<"action", TContext, Infer<TValidator>, TResult>;
+declare function action<TContext = unknown, TArgsShape extends ValidatorMap = ValidatorMap, TResult = unknown>(config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {
+  args: TArgsShape;
+}): SyncoreFunctionDefinition<"action", TContext, InferArgs<TArgsShape>, TResult>;
+interface RecurringIntervalSchedule {
+  type: "interval";
+  seconds?: number;
+  minutes?: number;
+  hours?: number;
+}
+interface RecurringDailySchedule {
+  type: "daily";
+  hour: number;
+  minute: number;
+  timezone?: string;
+}
+interface RecurringWeeklySchedule {
+  type: "weekly";
+  dayOfWeek: "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+  hour: number;
+  minute: number;
+  timezone?: string;
+}
+type RecurringSchedule = RecurringIntervalSchedule | RecurringDailySchedule | RecurringWeeklySchedule;
+type MisfirePolicy = {
+  type: "catch_up";
+} | {
+  type: "skip";
+} | {
+  type: "run_once_if_missed";
+} | {
+  type: "windowed";
+  windowMs: number;
+};
+interface RecurringJobDefinition {
+  name: string;
+  schedule: RecurringSchedule;
+  function: FunctionReference<"mutation" | "action">;
+  args: Record<string, unknown>;
+  misfirePolicy: MisfirePolicy;
+}
+declare class CronJobs {
+  readonly jobs: RecurringJobDefinition[];
+  interval(name: string, schedule: Omit<RecurringIntervalSchedule, "type">, functionReference: FunctionReference<"mutation" | "action">, args?: Record<string, unknown>, misfirePolicy?: MisfirePolicy): this;
+  daily(name: string, schedule: Omit<RecurringDailySchedule, "type">, functionReference: FunctionReference<"mutation" | "action">, args?: Record<string, unknown>, misfirePolicy?: MisfirePolicy): this;
+  weekly(name: string, schedule: Omit<RecurringWeeklySchedule, "type">, functionReference: FunctionReference<"mutation" | "action">, args?: Record<string, unknown>, misfirePolicy?: MisfirePolicy): this;
+}
+/**
+ * Create a recurring job registry for Syncore scheduler definitions.
+ */
+declare function cronJobs(): CronJobs;
+//#endregion
+export { CronJobs, EmptyArgs, FunctionArgs, FunctionArgsFromDefinition, FunctionConfig, FunctionKindFromDefinition, FunctionReference, FunctionReferenceFor, FunctionResult, FunctionResultFromDefinition, InferArgs, MisfirePolicy, RecurringDailySchedule, RecurringIntervalSchedule, RecurringJobDefinition, RecurringSchedule, RecurringWeeklySchedule, SyncoreFunctionDefinition, SyncoreFunctionKind, action, cronJobs, mutation, query };
+//# sourceMappingURL=functions.d.mts.map

package/dist/_vendor/core/runtime/functions.d.mts.map

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

package/dist/_vendor/core/runtime/functions.mjs

@@ -0,0 +1,71 @@
+import { ensureObjectValidator } from "../../schema/index.js";
+//#region src/runtime/functions.ts
+function createFunctionDefinition(kind, config) {
+	return {
+		kind,
+		argsValidator: ensureObjectValidator(config.args),
+		...config.returns ? { returnsValidator: config.returns } : {},
+		handler: config.handler
+	};
+}
+function query(config) {
+	return createFunctionDefinition("query", config);
+}
+function mutation(config) {
+	return createFunctionDefinition("mutation", config);
+}
+function action(config) {
+	return createFunctionDefinition("action", config);
+}
+var CronJobs = class {
+	jobs = [];
+	interval(name, schedule, functionReference, args = {}, misfirePolicy = { type: "catch_up" }) {
+		this.jobs.push({
+			name,
+			schedule: {
+				type: "interval",
+				...schedule
+			},
+			function: functionReference,
+			args,
+			misfirePolicy
+		});
+		return this;
+	}
+	daily(name, schedule, functionReference, args = {}, misfirePolicy = { type: "catch_up" }) {
+		this.jobs.push({
+			name,
+			schedule: {
+				type: "daily",
+				...schedule
+			},
+			function: functionReference,
+			args,
+			misfirePolicy
+		});
+		return this;
+	}
+	weekly(name, schedule, functionReference, args = {}, misfirePolicy = { type: "catch_up" }) {
+		this.jobs.push({
+			name,
+			schedule: {
+				type: "weekly",
+				...schedule
+			},
+			function: functionReference,
+			args,
+			misfirePolicy
+		});
+		return this;
+	}
+};
+/**
+* Create a recurring job registry for Syncore scheduler definitions.
+*/
+function cronJobs() {
+	return new CronJobs();
+}
+//#endregion
+export { CronJobs, action, cronJobs, mutation, query };
+
+//# sourceMappingURL=functions.mjs.map

package/dist/_vendor/core/runtime/functions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.mjs","names":[],"sources":["../../src/runtime/functions.ts"],"sourcesContent":["import {\r\n  ensureObjectValidator,\r\n  type Infer,\r\n  type Validator,\r\n  type ValidatorMap\r\n} from \"@syncore/schema\";\r\n\r\nexport type SyncoreFunctionKind = \"query\" | \"mutation\" | \"action\";\r\nexport type EmptyArgs = Record<never, never>;\r\n\r\n/**\r\n * A typed reference to a Syncore function.\r\n *\r\n * Most app code gets these references from the generated `api` object.\r\n */\r\nexport interface FunctionReference<\r\n  TKind extends SyncoreFunctionKind = SyncoreFunctionKind,\r\n  TArgs = EmptyArgs,\r\n  TResult = unknown\r\n> {\r\n  kind: TKind;\r\n  name: string;\r\n  readonly __args?: TArgs;\r\n  readonly __result?: TResult;\r\n}\r\n\r\nexport interface SyncoreFunctionDefinition<\r\n  TKind extends SyncoreFunctionKind,\r\n  TContext,\r\n  TArgs,\r\n  TResult\r\n> {\r\n  kind: TKind;\r\n  argsValidator: Validator<TArgs>;\r\n  returnsValidator?: Validator<TResult>;\r\n  handler: (ctx: TContext, args: TArgs) => Promise<TResult> | TResult;\r\n}\r\n\r\nexport type FunctionArgs<TReference> =\r\n  TReference extends FunctionReference<\r\n    SyncoreFunctionKind,\r\n    infer TArgs,\r\n    unknown\r\n  >\r\n    ? TArgs\r\n    : never;\r\n\r\nexport type FunctionResult<TReference> =\r\n  TReference extends FunctionReference<\r\n    SyncoreFunctionKind,\r\n    unknown,\r\n    infer TResult\r\n  >\r\n    ? TResult\r\n    : never;\r\n\r\nexport type FunctionKindFromDefinition<TDefinition> = TDefinition extends {\r\n  kind: infer TKind;\r\n}\r\n  ? Extract<TKind, SyncoreFunctionKind>\r\n  : never;\r\n\r\nexport type FunctionArgsFromDefinition<TDefinition> = TDefinition extends {\r\n  argsValidator: Validator<infer TArgs>;\r\n}\r\n  ? TArgs\r\n  : never;\r\n\r\nexport type FunctionResultFromDefinition<TDefinition> = TDefinition extends {\r\n  returnsValidator?: Validator<infer TResult>;\r\n}\r\n  ? TResult\r\n  : never;\r\n\r\nexport type FunctionReferenceFor<TDefinition> =\r\n  FunctionKindFromDefinition<TDefinition> extends never\r\n    ? never\r\n    : FunctionReference<\r\n        FunctionKindFromDefinition<TDefinition>,\r\n        FunctionArgsFromDefinition<TDefinition>,\r\n        FunctionResultFromDefinition<TDefinition>\r\n      >;\r\n\r\nexport interface FunctionConfig<TContext, TArgs, TResult> {\r\n  args: Validator<TArgs> | ValidatorMap;\r\n  returns?: Validator<TResult>;\r\n  handler: (ctx: TContext, args: TArgs) => Promise<TResult> | TResult;\r\n}\r\n\r\nexport type InferArgs<TArgs extends Validator<unknown> | ValidatorMap> =\r\n  TArgs extends Validator<unknown>\r\n    ? Infer<TArgs>\r\n    : TArgs extends ValidatorMap\r\n      ? {\r\n          [TKey in keyof TArgs]: Infer<TArgs[TKey]>;\r\n        }\r\n      : never;\r\n\r\nfunction createFunctionDefinition<\r\n  TKind extends SyncoreFunctionKind,\r\n  TContext,\r\n  TArgsShape extends Validator<unknown> | ValidatorMap,\r\n  TResult\r\n>(\r\n  kind: TKind,\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<TKind, TContext, InferArgs<TArgsShape>, TResult> {\r\n  return {\r\n    kind,\r\n    argsValidator: ensureObjectValidator(config.args) as Validator<\r\n      InferArgs<TArgsShape>\r\n    >,\r\n    ...(config.returns ? { returnsValidator: config.returns } : {}),\r\n    handler: config.handler\r\n  };\r\n}\r\n\r\n/**\r\n * Define a Syncore query.\r\n *\r\n * Queries can read local Syncore state and are available to clients.\r\n */\r\nexport function query<\r\n  TContext = unknown,\r\n  TValidator extends Validator<unknown> = Validator<unknown>,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {\r\n    args: TValidator;\r\n  }\r\n): SyncoreFunctionDefinition<\"query\", TContext, Infer<TValidator>, TResult>;\r\nexport function query<\r\n  TContext = unknown,\r\n  TArgsShape extends ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\"query\", TContext, InferArgs<TArgsShape>, TResult>;\r\nexport function query<\r\n  TContext = unknown,\r\n  TArgsShape extends Validator<unknown> | ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\r\n  \"query\",\r\n  TContext,\r\n  InferArgs<TArgsShape>,\r\n  TResult\r\n> {\r\n  return createFunctionDefinition(\"query\", config);\r\n}\r\n\r\n/**\r\n * Define a Syncore mutation.\r\n *\r\n * Mutations can modify local Syncore state and are available to clients.\r\n */\r\nexport function mutation<\r\n  TContext = unknown,\r\n  TValidator extends Validator<unknown> = Validator<unknown>,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {\r\n    args: TValidator;\r\n  }\r\n): SyncoreFunctionDefinition<\"mutation\", TContext, Infer<TValidator>, TResult>;\r\nexport function mutation<\r\n  TContext = unknown,\r\n  TArgsShape extends ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\r\n  \"mutation\",\r\n  TContext,\r\n  InferArgs<TArgsShape>,\r\n  TResult\r\n>;\r\nexport function mutation<\r\n  TContext = unknown,\r\n  TArgsShape extends Validator<unknown> | ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\r\n  \"mutation\",\r\n  TContext,\r\n  InferArgs<TArgsShape>,\r\n  TResult\r\n> {\r\n  return createFunctionDefinition(\"mutation\", config);\r\n}\r\n\r\n/**\r\n * Define a Syncore action.\r\n *\r\n * Actions can run arbitrary JavaScript and may call other Syncore functions.\r\n */\r\nexport function action<\r\n  TContext = unknown,\r\n  TValidator extends Validator<unknown> = Validator<unknown>,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, Infer<TValidator>, TResult> & {\r\n    args: TValidator;\r\n  }\r\n): SyncoreFunctionDefinition<\"action\", TContext, Infer<TValidator>, TResult>;\r\nexport function action<\r\n  TContext = unknown,\r\n  TArgsShape extends ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\r\n  \"action\",\r\n  TContext,\r\n  InferArgs<TArgsShape>,\r\n  TResult\r\n>;\r\nexport function action<\r\n  TContext = unknown,\r\n  TArgsShape extends Validator<unknown> | ValidatorMap = ValidatorMap,\r\n  TResult = unknown\r\n>(\r\n  config: FunctionConfig<TContext, InferArgs<TArgsShape>, TResult> & {\r\n    args: TArgsShape;\r\n  }\r\n): SyncoreFunctionDefinition<\r\n  \"action\",\r\n  TContext,\r\n  InferArgs<TArgsShape>,\r\n  TResult\r\n> {\r\n  return createFunctionDefinition(\"action\", config);\r\n}\r\n\r\nexport interface RecurringIntervalSchedule {\r\n  type: \"interval\";\r\n  seconds?: number;\r\n  minutes?: number;\r\n  hours?: number;\r\n}\r\n\r\nexport interface RecurringDailySchedule {\r\n  type: \"daily\";\r\n  hour: number;\r\n  minute: number;\r\n  timezone?: string;\r\n}\r\n\r\nexport interface RecurringWeeklySchedule {\r\n  type: \"weekly\";\r\n  dayOfWeek:\r\n    | \"sunday\"\r\n    | \"monday\"\r\n    | \"tuesday\"\r\n    | \"wednesday\"\r\n    | \"thursday\"\r\n    | \"friday\"\r\n    | \"saturday\";\r\n  hour: number;\r\n  minute: number;\r\n  timezone?: string;\r\n}\r\n\r\nexport type RecurringSchedule =\r\n  | RecurringIntervalSchedule\r\n  | RecurringDailySchedule\r\n  | RecurringWeeklySchedule;\r\n\r\nexport type MisfirePolicy =\r\n  | { type: \"catch_up\" }\r\n  | { type: \"skip\" }\r\n  | { type: \"run_once_if_missed\" }\r\n  | { type: \"windowed\"; windowMs: number };\r\n\r\nexport interface RecurringJobDefinition {\r\n  name: string;\r\n  schedule: RecurringSchedule;\r\n  function: FunctionReference<\"mutation\" | \"action\">;\r\n  args: Record<string, unknown>;\r\n  misfirePolicy: MisfirePolicy;\r\n}\r\n\r\nexport class CronJobs {\r\n  readonly jobs: RecurringJobDefinition[] = [];\r\n\r\n  interval(\r\n    name: string,\r\n    schedule: Omit<RecurringIntervalSchedule, \"type\">,\r\n    functionReference: FunctionReference<\"mutation\" | \"action\">,\r\n    args: Record<string, unknown> = {},\r\n    misfirePolicy: MisfirePolicy = { type: \"catch_up\" }\r\n  ): this {\r\n    this.jobs.push({\r\n      name,\r\n      schedule: { type: \"interval\", ...schedule },\r\n      function: functionReference,\r\n      args,\r\n      misfirePolicy\r\n    });\r\n    return this;\r\n  }\r\n\r\n  daily(\r\n    name: string,\r\n    schedule: Omit<RecurringDailySchedule, \"type\">,\r\n    functionReference: FunctionReference<\"mutation\" | \"action\">,\r\n    args: Record<string, unknown> = {},\r\n    misfirePolicy: MisfirePolicy = { type: \"catch_up\" }\r\n  ): this {\r\n    this.jobs.push({\r\n      name,\r\n      schedule: { type: \"daily\", ...schedule },\r\n      function: functionReference,\r\n      args,\r\n      misfirePolicy\r\n    });\r\n    return this;\r\n  }\r\n\r\n  weekly(\r\n    name: string,\r\n    schedule: Omit<RecurringWeeklySchedule, \"type\">,\r\n    functionReference: FunctionReference<\"mutation\" | \"action\">,\r\n    args: Record<string, unknown> = {},\r\n    misfirePolicy: MisfirePolicy = { type: \"catch_up\" }\r\n  ): this {\r\n    this.jobs.push({\r\n      name,\r\n      schedule: { type: \"weekly\", ...schedule },\r\n      function: functionReference,\r\n      args,\r\n      misfirePolicy\r\n    });\r\n    return this;\r\n  }\r\n}\r\n\r\n/**\r\n * Create a recurring job registry for Syncore scheduler definitions.\r\n */\r\nexport function cronJobs(): CronJobs {\r\n  return new CronJobs();\r\n}\r\n"],"mappings":";;AAkGA,SAAS,yBAMP,MACA,QAG4E;AAC5E,QAAO;EACL;EACA,eAAe,sBAAsB,OAAO,KAAK;EAGjD,GAAI,OAAO,UAAU,EAAE,kBAAkB,OAAO,SAAS,GAAG,EAAE;EAC9D,SAAS,OAAO;EACjB;;AA0BH,SAAgB,MAKd,QAQA;AACA,QAAO,yBAAyB,SAAS,OAAO;;AA+BlD,SAAgB,SAKd,QAQA;AACA,QAAO,yBAAyB,YAAY,OAAO;;AA+BrD,SAAgB,OAKd,QAQA;AACA,QAAO,yBAAyB,UAAU,OAAO;;AAmDnD,IAAa,WAAb,MAAsB;CACpB,OAA0C,EAAE;CAE5C,SACE,MACA,UACA,mBACA,OAAgC,EAAE,EAClC,gBAA+B,EAAE,MAAM,YAAY,EAC7C;AACN,OAAK,KAAK,KAAK;GACb;GACA,UAAU;IAAE,MAAM;IAAY,GAAG;IAAU;GAC3C,UAAU;GACV;GACA;GACD,CAAC;AACF,SAAO;;CAGT,MACE,MACA,UACA,mBACA,OAAgC,EAAE,EAClC,gBAA+B,EAAE,MAAM,YAAY,EAC7C;AACN,OAAK,KAAK,KAAK;GACb;GACA,UAAU;IAAE,MAAM;IAAS,GAAG;IAAU;GACxC,UAAU;GACV;GACA;GACD,CAAC;AACF,SAAO;;CAGT,OACE,MACA,UACA,mBACA,OAAgC,EAAE,EAClC,gBAA+B,EAAE,MAAM,YAAY,EAC7C;AACN,OAAK,KAAK,KAAK;GACb;GACA,UAAU;IAAE,MAAM;IAAU,GAAG;IAAU;GACzC,UAAU;GACV;GACA;GACD,CAAC;AACF,SAAO;;;;;;AAOX,SAAgB,WAAqB;AACnC,QAAO,IAAI,UAAU"}

package/dist/_vendor/core/runtime/id.d.mts

@@ -0,0 +1,13 @@
+//#region src/runtime/id.d.ts
+/**
+ * Generate a random UUID v4 string.
+ *
+ * Prefers `crypto.randomUUID()` when available (secure contexts, Node 19+,
+ * web workers). Falls back to building a v4 UUID from
+ * `crypto.getRandomValues()` for non-secure contexts such as `http://`
+ * dev servers.
+ */
+declare function generateId(): string;
+//#endregion
+export { generateId };
+//# sourceMappingURL=id.d.mts.map

package/dist/_vendor/core/runtime/id.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.mts","names":[],"sources":["../../src/runtime/id.ts"],"mappings":";;AAQA;;;;;;;iBAAgB,UAAA,CAAA"}

package/dist/_vendor/core/runtime/id.mjs

@@ -0,0 +1,28 @@
+//#region src/runtime/id.ts
+/**
+* Generate a random UUID v4 string.
+*
+* Prefers `crypto.randomUUID()` when available (secure contexts, Node 19+,
+* web workers). Falls back to building a v4 UUID from
+* `crypto.getRandomValues()` for non-secure contexts such as `http://`
+* dev servers.
+*/
+function generateId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return [
+		hex.slice(0, 8),
+		hex.slice(8, 12),
+		hex.slice(12, 16),
+		hex.slice(16, 20),
+		hex.slice(20, 32)
+	].join("-");
+}
+//#endregion
+export { generateId };
+
+//# sourceMappingURL=id.mjs.map

package/dist/_vendor/core/runtime/id.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.mjs","names":[],"sources":["../../src/runtime/id.ts"],"sourcesContent":["/**\n * Generate a random UUID v4 string.\n *\n * Prefers `crypto.randomUUID()` when available (secure contexts, Node 19+,\n * web workers). Falls back to building a v4 UUID from\n * `crypto.getRandomValues()` for non-secure contexts such as `http://`\n * dev servers.\n */\nexport function generateId(): string {\n  if (\n    typeof crypto !== \"undefined\" &&\n    typeof crypto.randomUUID === \"function\"\n  ) {\n    return crypto.randomUUID();\n  }\n\n  // Fallback: build a UUID v4 from getRandomValues.\n  // Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\n  const bytes = new Uint8Array(16);\n  crypto.getRandomValues(bytes);\n\n  // Set version (4) and variant (10xx) bits per RFC 4122.\n  bytes[6] = (bytes[6]! & 0x0f) | 0x40;\n  bytes[8] = (bytes[8]! & 0x3f) | 0x80;\n\n  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, \"0\")).join(\n    \"\"\n  );\n\n  return [\n    hex.slice(0, 8),\n    hex.slice(8, 12),\n    hex.slice(12, 16),\n    hex.slice(16, 20),\n    hex.slice(20, 32)\n  ].join(\"-\");\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,aAAqB;AACnC,KACE,OAAO,WAAW,eAClB,OAAO,OAAO,eAAe,WAE7B,QAAO,OAAO,YAAY;CAK5B,MAAM,QAAQ,IAAI,WAAW,GAAG;AAChC,QAAO,gBAAgB,MAAM;AAG7B,OAAM,KAAM,MAAM,KAAM,KAAQ;AAChC,OAAM,KAAM,MAAM,KAAM,KAAQ;CAEhC,MAAM,MAAM,MAAM,KAAK,QAAQ,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,KACpE,GACD;AAED,QAAO;EACL,IAAI,MAAM,GAAG,EAAE;EACf,IAAI,MAAM,GAAG,GAAG;EAChB,IAAI,MAAM,IAAI,GAAG;EACjB,IAAI,MAAM,IAAI,GAAG;EACjB,IAAI,MAAM,IAAI,GAAG;EAClB,CAAC,KAAK,IAAI"}

package/dist/_vendor/core/runtime/runtime.d.mts

@@ -0,0 +1,370 @@
+import { FunctionArgsFromDefinition, FunctionKindFromDefinition, FunctionReference, FunctionResultFromDefinition, MisfirePolicy, RecurringJobDefinition, SyncoreFunctionKind } from "./functions.mjs";
+import { InferDocument, InferTableInput, SyncoreSchema, Validator } from "../../schema/index.d.ts";
+import { SyncoreDevtoolsEvent, SyncoreDevtoolsSnapshot } from "../../devtools-protocol/index.d.ts";
+
+//#region src/runtime/runtime.d.ts
+interface RegisteredSyncoreFunction {
+  kind: SyncoreFunctionKind;
+  argsValidator: Validator<unknown>;
+  returnsValidator?: Validator<unknown>;
+  handler: RegisteredSyncoreHandler;
+}
+interface SyncoreFunctionRegistry {
+  readonly [name: string]: RegisteredSyncoreFunction | undefined;
+}
+type RegisteredSyncoreHandler = {
+  bivarianceHack(ctx: unknown, args: unknown): unknown;
+}["bivarianceHack"];
+type JsonObject = Record<string, unknown>;
+type ComparisonOperator = "=" | ">" | ">=" | "<" | "<=";
+type QueryCondition = {
+  field: string;
+  operator: ComparisonOperator;
+  value: unknown;
+};
+type QueryExpression = {
+  type: "condition";
+  condition: QueryCondition;
+} | {
+  type: "and";
+  expressions: QueryExpression[];
+} | {
+  type: "or";
+  expressions: QueryExpression[];
+};
+type SearchQuery = {
+  searchField: string;
+  searchText: string;
+  filters: QueryCondition[];
+};
+interface RunResult {
+  changes: number;
+  lastInsertRowid?: number | string;
+}
+interface SyncoreSqlDriver {
+  exec(sql: string): Promise<void>;
+  run(sql: string, params?: unknown[]): Promise<RunResult>;
+  get<T>(sql: string, params?: unknown[]): Promise<T | undefined>;
+  all<T>(sql: string, params?: unknown[]): Promise<T[]>;
+  withTransaction<T>(callback: () => Promise<T>): Promise<T>;
+  withSavepoint<T>(name: string, callback: () => Promise<T>): Promise<T>;
+  close?(): Promise<void>;
+}
+/**
+ * The binary or text payload written through Syncore storage APIs.
+ */
+interface StorageWriteInput {
+  data: Uint8Array | ArrayBuffer | string;
+  contentType?: string;
+  fileName?: string;
+}
+/**
+ * Metadata about an object stored through Syncore storage APIs.
+ */
+interface StorageObject {
+  id: string;
+  path: string;
+  size: number;
+  contentType: string | null;
+}
+interface SyncoreStorageAdapter {
+  put(id: string, input: StorageWriteInput): Promise<StorageObject>;
+  get(id: string): Promise<StorageObject | null>;
+  read(id: string): Promise<Uint8Array | null>;
+  delete(id: string): Promise<void>;
+  list?(): Promise<StorageObject[]>;
+}
+interface DevtoolsSink {
+  emit(event: SyncoreDevtoolsEvent): void;
+}
+interface SchedulerOptions {
+  pollIntervalMs?: number;
+  recurringJobs?: RecurringJobDefinition[];
+}
+interface SyncoreCapabilities {
+  [name: string]: unknown;
+}
+interface SyncoreExperimentalPluginContext<TSchema extends AnySyncoreSchema> {
+  runtimeId: string;
+  platform: string;
+  schema: TSchema;
+  driver: SyncoreSqlDriver;
+  storage: SyncoreStorageAdapter;
+  scheduler?: SchedulerOptions;
+  devtools?: DevtoolsSink;
+  emitDevtools(event: SyncoreDevtoolsEvent): void;
+}
+interface SyncoreExperimentalPlugin<TSchema extends AnySyncoreSchema> {
+  name: string;
+  capabilities?: SyncoreCapabilities | ((context: SyncoreExperimentalPluginContext<TSchema>) => SyncoreCapabilities | void);
+  onStart?(context: SyncoreExperimentalPluginContext<TSchema>): Promise<void> | void;
+  onStop?(context: SyncoreExperimentalPluginContext<TSchema>): Promise<void> | void;
+}
+interface SyncoreRuntimeOptions<TSchema extends AnySyncoreSchema> {
+  schema: TSchema;
+  functions: SyncoreFunctionRegistry;
+  driver: SyncoreSqlDriver;
+  storage: SyncoreStorageAdapter;
+  capabilities?: SyncoreCapabilities;
+  experimentalPlugins?: Array<SyncoreExperimentalPlugin<TSchema>>;
+  platform?: string;
+  devtools?: DevtoolsSink;
+  scheduler?: SchedulerOptions;
+}
+interface PaginationOptions {
+  cursor?: string | null;
+  numItems: number;
+}
+interface PaginationResult<TItem> {
+  /** The current page of results. */
+  page: TItem[];
+  /** The cursor to pass to the next page request, or `null` when finished. */
+  cursor: string | null;
+  /** Whether there are no more pages to read. */
+  isDone: boolean;
+}
+interface SyncoreWatch<TValue> {
+  /** Subscribe to updates for this query watch. */
+  onUpdate(callback: () => void): () => void;
+  /** Read the latest local query result, if one is available. */
+  localQueryResult(): TValue | undefined;
+  /** Read the latest local query error, if one is available. */
+  localQueryError(): Error | undefined;
+  /** Dispose the watch if the implementation exposes explicit cleanup. */
+  dispose?(): void;
+}
+interface FilterBuilder {
+  /** Match documents whose field is exactly equal to a value. */
+  eq(field: string, value: unknown): QueryExpression;
+  /** Match documents whose field is greater than a value. */
+  gt(field: string, value: unknown): QueryExpression;
+  /** Match documents whose field is greater than or equal to a value. */
+  gte(field: string, value: unknown): QueryExpression;
+  /** Match documents whose field is less than a value. */
+  lt(field: string, value: unknown): QueryExpression;
+  /** Match documents whose field is less than or equal to a value. */
+  lte(field: string, value: unknown): QueryExpression;
+  /** Combine several filter expressions with logical AND. */
+  and(...expressions: QueryExpression[]): QueryExpression;
+  /** Combine several filter expressions with logical OR. */
+  or(...expressions: QueryExpression[]): QueryExpression;
+}
+interface IndexRangeBuilder {
+  /** Constrain an indexed field to an exact value. */
+  eq(field: string, value: unknown): IndexRangeBuilder;
+  /** Constrain an indexed field to values greater than a value. */
+  gt(field: string, value: unknown): IndexRangeBuilder;
+  /** Constrain an indexed field to values greater than or equal to a value. */
+  gte(field: string, value: unknown): IndexRangeBuilder;
+  /** Constrain an indexed field to values less than a value. */
+  lt(field: string, value: unknown): IndexRangeBuilder;
+  /** Constrain an indexed field to values less than or equal to a value. */
+  lte(field: string, value: unknown): IndexRangeBuilder;
+  /** Finish building the index range. */
+  build(): QueryCondition[];
+}
+interface SearchIndexBuilder {
+  /** Set the text field and text to search for. */
+  search(field: string, value: string): SearchIndexBuilder;
+  /** Add an equality filter alongside the text search. */
+  eq(field: string, value: unknown): SearchIndexBuilder;
+  /** Finish building the search query. */
+  build(): SearchQuery;
+}
+type AnySyncoreSchema = SyncoreSchema<any>;
+type TableNames<TSchema extends AnySyncoreSchema> = Extract<keyof TSchema["tables"], string>;
+type DocumentForTable<TSchema extends AnySyncoreSchema, TTableName extends TableNames<TSchema>> = InferDocument<TSchema["tables"][TTableName]>;
+type InsertValueForTable<TSchema extends AnySyncoreSchema, TTableName extends TableNames<TSchema>> = InferTableInput<TSchema["tables"][TTableName]>;
+type OptionalArgsTuple<TArgs> = Record<never, never> extends TArgs ? [args?: TArgs] : [args: TArgs];
+interface SyncoreDatabaseReader<TSchema extends AnySyncoreSchema = AnySyncoreSchema> {
+  /** Read a single document by table name and id. */
+  get<TTableName extends TableNames<TSchema>>(table: TTableName, id: string): Promise<DocumentForTable<TSchema, TTableName> | null>;
+  /** Start building a table query. */
+  query<TTableName extends TableNames<TSchema>>(table: TTableName): QueryBuilder<DocumentForTable<TSchema, TTableName>>;
+  /** Run raw SQL against the local Syncore database. */
+  raw<TValue = unknown>(sql: string, params?: unknown[]): Promise<TValue[]>;
+}
+interface SyncoreDatabaseWriter<TSchema extends AnySyncoreSchema = AnySyncoreSchema> extends SyncoreDatabaseReader<TSchema> {
+  /** Insert a new document into a table and return its generated id. */
+  insert<TTableName extends TableNames<TSchema>>(table: TTableName, value: InsertValueForTable<TSchema, TTableName>): Promise<string>;
+  /** Apply a partial update to an existing document. */
+  patch<TTableName extends TableNames<TSchema>>(table: TTableName, id: string, value: Partial<InsertValueForTable<TSchema, TTableName>>): Promise<void>;
+  /** Replace an existing document with a full new value. */
+  replace<TTableName extends TableNames<TSchema>>(table: TTableName, id: string, value: InsertValueForTable<TSchema, TTableName>): Promise<void>;
+  /** Delete a document from a table. */
+  delete<TTableName extends TableNames<TSchema>>(table: TTableName, id: string): Promise<void>;
+}
+/**
+ * The storage API exposed inside Syncore runtime contexts.
+ */
+interface SyncoreStorageApi {
+  /** Store a file-like payload locally and return its generated id. */
+  put(input: StorageWriteInput): Promise<string>;
+  /** Read metadata for a stored object. */
+  get(id: string): Promise<StorageObject | null>;
+  /** Read the stored bytes for an object. */
+  read(id: string): Promise<Uint8Array | null>;
+  /** Delete a stored object. */
+  delete(id: string): Promise<void>;
+}
+interface SchedulerApi {
+  /** Schedule a mutation or action to run after a delay. */
+  runAfter<TArgs, TResult>(delayMs: number, functionReference: FunctionReference<"mutation" | "action", TArgs, TResult>, ...args: [...OptionalArgsTuple<TArgs>, misfirePolicy?: MisfirePolicy]): Promise<string>;
+  /** Schedule a mutation or action to run at a specific time. */
+  runAt<TArgs, TResult>(timestamp: number | Date, functionReference: FunctionReference<"mutation" | "action", TArgs, TResult>, ...args: [...OptionalArgsTuple<TArgs>, misfirePolicy?: MisfirePolicy]): Promise<string>;
+  /** Cancel a previously scheduled job. */
+  cancel(id: string): Promise<void>;
+}
+/**
+ * The context object available inside Syncore queries.
+ */
+interface QueryCtx<TSchema extends AnySyncoreSchema = AnySyncoreSchema> {
+  /** Read-only database access for this query. */
+  db: SyncoreDatabaseReader<TSchema>;
+  /** Local file/blob storage for this runtime. */
+  storage: SyncoreStorageApi;
+  /** Optional adapter or plugin capabilities exposed by the runtime. */
+  capabilities?: Readonly<SyncoreCapabilities>;
+  /** Call another Syncore query from inside this query. */
+  runQuery<TArgs, TResult>(reference: FunctionReference<"query", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+}
+/**
+ * The context object available inside Syncore mutations.
+ */
+interface MutationCtx<TSchema extends AnySyncoreSchema = AnySyncoreSchema> extends QueryCtx<TSchema> {
+  db: SyncoreDatabaseWriter<TSchema>;
+  /** Schedule future work from this mutation. */
+  scheduler: SchedulerApi;
+  /** Call another mutation from inside this mutation. */
+  runMutation<TArgs, TResult>(reference: FunctionReference<"mutation", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+  /** Call an action from this mutation. */
+  runAction<TArgs, TResult>(reference: FunctionReference<"action", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+}
+/**
+ * The context object available inside Syncore actions.
+ */
+interface ActionCtx<TSchema extends AnySyncoreSchema = AnySyncoreSchema> extends QueryCtx<TSchema> {
+  /** Schedule future work from this action. */
+  scheduler: SchedulerApi;
+  /** Call a mutation from this action. */
+  runMutation<TArgs, TResult>(reference: FunctionReference<"mutation", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+  /** Call another action from this action. */
+  runAction<TArgs, TResult>(reference: FunctionReference<"action", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+}
+/**
+ * The typed client API exposed by a Syncore runtime.
+ */
+interface SyncoreClient {
+  /** Fetch a query result once. */
+  query<TArgs, TResult>(reference: FunctionReference<"query", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+  /** Execute a mutation. */
+  mutation<TArgs, TResult>(reference: FunctionReference<"mutation", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+  /** Execute an action. */
+  action<TArgs, TResult>(reference: FunctionReference<"action", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): Promise<TResult>;
+  /** Subscribe to a query and receive reactive updates. */
+  watchQuery<TArgs, TResult>(reference: FunctionReference<"query", TArgs, TResult>, ...args: OptionalArgsTuple<TArgs>): SyncoreWatch<TResult>;
+}
+/**
+ * A composable builder for Syncore table queries.
+ */
+interface QueryBuilder<TDocument> {
+  /** Query through a named index instead of scanning the whole table. */
+  withIndex(indexName: string, builder?: (range: IndexRangeBuilder) => IndexRangeBuilder): this;
+  /** Query through a named search index for text search. */
+  withSearchIndex(indexName: string, builder: (search: SearchIndexBuilder) => SearchIndexBuilder): this;
+  /** Set the result ordering. */
+  order(order: "asc" | "desc"): this;
+  /** Add a filter expression to the query. */
+  filter(builder: (filter: FilterBuilder) => QueryExpression): this;
+  /** Collect all matching documents. */
+  collect(): Promise<TDocument[]>;
+  /** Collect up to a fixed number of matching documents. */
+  take(count: number): Promise<TDocument[]>;
+  /** Return the first matching document, or `null` if none exist. */
+  first(): Promise<TDocument | null>;
+  /** Return one matching document and throw if multiple rows match. */
+  unique(): Promise<TDocument | null>;
+  /** Read a paginated slice of documents using a cursor. */
+  paginate(options: PaginationOptions): Promise<PaginationResult<TDocument>>;
+}
+/**
+ * The local Syncore runtime that owns the database, storage, scheduler, and function execution.
+ */
+declare class SyncoreRuntime<TSchema extends AnySyncoreSchema> {
+  private readonly options;
+  private readonly runtimeId;
+  private readonly platform;
+  private readonly capabilities;
+  private readonly experimentalPlugins;
+  private readonly activeQueries;
+  private readonly disabledSearchIndexes;
+  private readonly recentEvents;
+  private schedulerTimer;
+  private readonly recurringJobs;
+  private readonly schedulerPollIntervalMs;
+  private started;
+  constructor(options: SyncoreRuntimeOptions<TSchema>);
+  /**
+   * Start the local Syncore runtime.
+   */
+  start(): Promise<void>;
+  /**
+   * Stop the local Syncore runtime and release any open resources.
+   */
+  stop(): Promise<void>;
+  /**
+   * Create a typed client for calling this runtime from the same process.
+   */
+  createClient(): SyncoreClient;
+  getDevtoolsSnapshot(): SyncoreDevtoolsSnapshot;
+  getRuntimeId(): string;
+  runQuery<TArgs, TResult>(reference: FunctionReference<"query", TArgs, TResult>, args?: JsonObject): Promise<TResult>;
+  runMutation<TArgs, TResult>(reference: FunctionReference<"mutation", TArgs, TResult>, args?: JsonObject): Promise<TResult>;
+  runAction<TArgs, TResult>(reference: FunctionReference<"action", TArgs, TResult>, args?: JsonObject): Promise<TResult>;
+  watchQuery<TArgs, TResult>(reference: FunctionReference<"query", TArgs, TResult>, args?: JsonObject): SyncoreWatch<TResult>;
+  private executeQueryBuilder;
+  private invokeFunction;
+  private createContext;
+  private createDatabaseReader;
+  private createDatabaseWriter;
+  private createStorageApi;
+  private createSchedulerApi;
+  private ensureSystemTables;
+  private reconcileStorageState;
+  private applySchema;
+  private scheduleJob;
+  private syncRecurringJobs;
+  private processDueJobs;
+  private advanceOrFinalizeJob;
+  private refreshInvalidatedQueries;
+  private rerunActiveQuery;
+  private collectQueryDependencies;
+  private resolveFunction;
+  private validateDocument;
+  private deserializeDocument;
+  private syncSearchIndexes;
+  private removeSearchIndexes;
+  private renderExpression;
+  private renderCondition;
+  private createActiveQueryKey;
+  private emitDevtools;
+  private createPluginContext;
+  private buildCapabilities;
+  private runPluginHook;
+  private findSearchIndexKeyForStatement;
+  private getTableDefinition;
+}
+declare function createFunctionReference<TKind extends SyncoreFunctionKind, TArgs = Record<never, never>, TResult = unknown>(kind: TKind, name: string): FunctionReference<TKind, TArgs, TResult>;
+/**
+ * Create a typed function reference from a concrete Syncore function definition.
+ *
+ * Generated code uses this helper to preserve function arg and result inference.
+ */
+declare function createFunctionReferenceFor<TDefinition extends {
+  kind: SyncoreFunctionKind;
+  argsValidator: Validator<unknown>;
+  returnsValidator?: Validator<unknown>;
+}>(kind: FunctionKindFromDefinition<TDefinition>, name: string): FunctionReference<FunctionKindFromDefinition<TDefinition>, FunctionArgsFromDefinition<TDefinition>, FunctionResultFromDefinition<TDefinition>>;
+//#endregion
+export { ActionCtx, AnySyncoreSchema, ComparisonOperator, DevtoolsSink, DocumentForTable, FilterBuilder, IndexRangeBuilder, InsertValueForTable, JsonObject, MutationCtx, PaginationOptions, PaginationResult, QueryBuilder, QueryCondition, QueryCtx, QueryExpression, RegisteredSyncoreFunction, RegisteredSyncoreHandler, RunResult, SchedulerApi, SchedulerOptions, SearchIndexBuilder, SearchQuery, StorageObject, StorageWriteInput, SyncoreCapabilities, SyncoreClient, SyncoreDatabaseReader, SyncoreDatabaseWriter, SyncoreExperimentalPlugin, SyncoreExperimentalPluginContext, SyncoreFunctionRegistry, SyncoreRuntime, SyncoreRuntimeOptions, SyncoreSqlDriver, SyncoreStorageAdapter, SyncoreStorageApi, SyncoreWatch, TableNames, createFunctionReference, createFunctionReferenceFor };
+//# sourceMappingURL=runtime.d.mts.map