@farm.js/core 0.1.61 → 0.1.63

package/dist/runtime.d-3iJAKptR.d.mts

@@ -0,0 +1,28 @@
+import { F as FarmLocaleResolution } from './resolver.d-JnZKKsc5.mjs';
+import { R as ResolvedFarmI18nConfig, F as FarmI18nCatalogs, a as FarmI18nClientSnapshot } from './types.d-C41ePjvP.mjs';
+
+declare class FarmI18nRuntime {
+    readonly config: ResolvedFarmI18nConfig;
+    private catalogs;
+    private compiled;
+    private warnedMissing;
+    constructor(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs);
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    replaceCatalogs(catalogs: FarmI18nCatalogs): void;
+    getCatalogs(): FarmI18nCatalogs;
+    resolveRequest(request: Request, options?: {
+        redirect?: boolean;
+    }): FarmLocaleResolution;
+    translate(locale: string, key: string, values?: Record<string, unknown>): string;
+    translateRich(locale: string, key: string, values?: Record<string, unknown>): unknown;
+    getRawMessage(locale: string, key: string): string;
+    hasMessage(locale: string, key: string): boolean;
+    getClientSnapshot(resolution: FarmLocaleResolution): FarmI18nClientSnapshot;
+    private formatMessage;
+    private readOwnMessage;
+    private resolveMessage;
+}
+declare function createFarmI18nRuntime(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs): FarmI18nRuntime;
+
+export { FarmI18nRuntime as F, createFarmI18nRuntime as c };

package/dist/runtime.d-BtL3PCL3.d.ts

@@ -0,0 +1,28 @@
+import { F as FarmLocaleResolution } from './resolver.d-BHyZgpa7.js';
+import { R as ResolvedFarmI18nConfig, F as FarmI18nCatalogs, a as FarmI18nClientSnapshot } from './types.d-C41ePjvP.js';
+
+declare class FarmI18nRuntime {
+    readonly config: ResolvedFarmI18nConfig;
+    private catalogs;
+    private compiled;
+    private warnedMissing;
+    constructor(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs);
+    initialize(): Promise<void>;
+    reload(): Promise<void>;
+    replaceCatalogs(catalogs: FarmI18nCatalogs): void;
+    getCatalogs(): FarmI18nCatalogs;
+    resolveRequest(request: Request, options?: {
+        redirect?: boolean;
+    }): FarmLocaleResolution;
+    translate(locale: string, key: string, values?: Record<string, unknown>): string;
+    translateRich(locale: string, key: string, values?: Record<string, unknown>): unknown;
+    getRawMessage(locale: string, key: string): string;
+    hasMessage(locale: string, key: string): boolean;
+    getClientSnapshot(resolution: FarmLocaleResolution): FarmI18nClientSnapshot;
+    private formatMessage;
+    private readOwnMessage;
+    private resolveMessage;
+}
+declare function createFarmI18nRuntime(config: ResolvedFarmI18nConfig, catalogs?: FarmI18nCatalogs): FarmI18nRuntime;
+
+export { FarmI18nRuntime as F, createFarmI18nRuntime as c };

package/dist/runtime.d-CCsjTZJW.d.ts

@@ -0,0 +1,69 @@
+import { f as EndpointFailure } from './endpoint.d-BgHn0lhl.js';
+import { c as PluginRoutesFactory } from './route.d-DBTEqifW.js';
+import { b as APIRouteParams, A as APIRouteMatch } from './route-pattern.d-CVsVbq5n.js';
+import './client-plugins.d-BgPUYPc9.js';
+
+interface MountedRoute {
+    path: string;
+    methods: string[];
+    endpoints: Record<string, any>;
+    filePath?: string;
+    pluginMethods?: string[];
+}
+/** The same registration step is used by dev discovery and the production bundle. */
+declare function mergePluginAPIRoutes(existing: readonly MountedRoute[], plugins: readonly {
+    name: string;
+    routes?: PluginRoutesFactory;
+}[], expected?: readonly {
+    path: string;
+    methods: readonly string[];
+}[], options?: {
+    bodySizeLimit?: number;
+    /**
+     * Sends a plugin's `api.get(...).invoke()` call through the app's request pipeline, so the
+     * endpoint's middleware, integration guards and route rules run for its own path as they do
+     * for a direct request. Without it the endpoint is called directly.
+     */
+    dispatch?: PluginAPIDispatch;
+}): Array<MountedRoute & {
+    filePath: string;
+}>;
+/** Runs a request for an app endpoint through the app's own request pipeline. */
+type PluginAPIDispatch = (request: Request) => Response | Promise<Response>;
+
+interface APIRouteShapeSource<TSource> {
+    routePath: string;
+    source: TSource;
+    filePath: string;
+}
+/** Validate API URL shapes and return the lower-priority route replaced by this source. */
+declare function registerAPIRouteShape<TSource>(shapes: Map<string, APIRouteShapeSource<TSource>>, routePath: string, filePath: string, source: TSource): string | undefined;
+
+/**
+ * Every method an API route module can export. Route discovery in core and in
+ * the plain-Vite plugin reads this list, so a handler exported under any of
+ * these names is served wherever the route is.
+ */
+declare const API_ROUTE_METHODS: readonly ["GET", "HEAD", "QUERY", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+interface APIRouteMethodTable {
+    methods: string[];
+    endpoints: Record<string, any>;
+}
+declare function resolveAPIRouteEndpoint(route: APIRouteMethodTable, method: string): any | undefined;
+declare function getAllowedAPIRouteMethods(route: APIRouteMethodTable): string[];
+/** Match canonical routes through a configurable same-origin public API path. */
+declare function matchAPIRouteAtBasePath<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string, serverBasePath?: string): APIRouteMatch<T> | null;
+/** @internal Prepare the fixed API table owned by a generated production bundle. */
+declare function createStaticAPIRouteMatcherAtBasePath<T extends {
+    path: string;
+}>(routes: readonly T[], serverBasePath?: string): (pathname: string) => APIRouteMatch<T> | null;
+/** Test whether a pathname belongs to the configured local API surface. */
+declare function isFarmAPIPathname(pathname: string, serverBasePath?: string): boolean;
+declare function invokeAPIRouteEndpoint(endpoint: any, request: Request, params?: APIRouteParams, bodySizeLimit?: number): Promise<Response>;
+declare function normalizeRouteResponse(result: unknown): Response;
+declare function isWebResponse(value: unknown): value is Response;
+declare function createEndpointFailureResponse(failure: EndpointFailure<string, unknown>): Response;
+
+export { API_ROUTE_METHODS as A, type PluginAPIDispatch as P, isWebResponse as a, type APIRouteShapeSource as b, createEndpointFailureResponse as c, createStaticAPIRouteMatcherAtBasePath as d, isFarmAPIPathname as e, mergePluginAPIRoutes as f, getAllowedAPIRouteMethods as g, registerAPIRouteShape as h, invokeAPIRouteEndpoint as i, matchAPIRouteAtBasePath as m, normalizeRouteResponse as n, resolveAPIRouteEndpoint as r };

package/dist/runtime.d-CETtpLb-.d.mts

@@ -0,0 +1,69 @@
+import { f as EndpointFailure } from './endpoint.d-BkMSCRf6.mjs';
+import { c as PluginRoutesFactory } from './route.d-BaVH3V0w.mjs';
+import { b as APIRouteParams, A as APIRouteMatch } from './route-pattern.d-CVsVbq5n.mjs';
+import './client-plugins.d-BTF0gZm4.mjs';
+
+interface MountedRoute {
+    path: string;
+    methods: string[];
+    endpoints: Record<string, any>;
+    filePath?: string;
+    pluginMethods?: string[];
+}
+/** The same registration step is used by dev discovery and the production bundle. */
+declare function mergePluginAPIRoutes(existing: readonly MountedRoute[], plugins: readonly {
+    name: string;
+    routes?: PluginRoutesFactory;
+}[], expected?: readonly {
+    path: string;
+    methods: readonly string[];
+}[], options?: {
+    bodySizeLimit?: number;
+    /**
+     * Sends a plugin's `api.get(...).invoke()` call through the app's request pipeline, so the
+     * endpoint's middleware, integration guards and route rules run for its own path as they do
+     * for a direct request. Without it the endpoint is called directly.
+     */
+    dispatch?: PluginAPIDispatch;
+}): Array<MountedRoute & {
+    filePath: string;
+}>;
+/** Runs a request for an app endpoint through the app's own request pipeline. */
+type PluginAPIDispatch = (request: Request) => Response | Promise<Response>;
+
+interface APIRouteShapeSource<TSource> {
+    routePath: string;
+    source: TSource;
+    filePath: string;
+}
+/** Validate API URL shapes and return the lower-priority route replaced by this source. */
+declare function registerAPIRouteShape<TSource>(shapes: Map<string, APIRouteShapeSource<TSource>>, routePath: string, filePath: string, source: TSource): string | undefined;
+
+/**
+ * Every method an API route module can export. Route discovery in core and in
+ * the plain-Vite plugin reads this list, so a handler exported under any of
+ * these names is served wherever the route is.
+ */
+declare const API_ROUTE_METHODS: readonly ["GET", "HEAD", "QUERY", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"];
+interface APIRouteMethodTable {
+    methods: string[];
+    endpoints: Record<string, any>;
+}
+declare function resolveAPIRouteEndpoint(route: APIRouteMethodTable, method: string): any | undefined;
+declare function getAllowedAPIRouteMethods(route: APIRouteMethodTable): string[];
+/** Match canonical routes through a configurable same-origin public API path. */
+declare function matchAPIRouteAtBasePath<T extends {
+    path: string;
+}>(routes: Map<string, T>, pathname: string, serverBasePath?: string): APIRouteMatch<T> | null;
+/** @internal Prepare the fixed API table owned by a generated production bundle. */
+declare function createStaticAPIRouteMatcherAtBasePath<T extends {
+    path: string;
+}>(routes: readonly T[], serverBasePath?: string): (pathname: string) => APIRouteMatch<T> | null;
+/** Test whether a pathname belongs to the configured local API surface. */
+declare function isFarmAPIPathname(pathname: string, serverBasePath?: string): boolean;
+declare function invokeAPIRouteEndpoint(endpoint: any, request: Request, params?: APIRouteParams, bodySizeLimit?: number): Promise<Response>;
+declare function normalizeRouteResponse(result: unknown): Response;
+declare function isWebResponse(value: unknown): value is Response;
+declare function createEndpointFailureResponse(failure: EndpointFailure<string, unknown>): Response;
+
+export { API_ROUTE_METHODS as A, type PluginAPIDispatch as P, isWebResponse as a, type APIRouteShapeSource as b, createEndpointFailureResponse as c, createStaticAPIRouteMatcherAtBasePath as d, isFarmAPIPathname as e, mergePluginAPIRoutes as f, getAllowedAPIRouteMethods as g, registerAPIRouteShape as h, invokeAPIRouteEndpoint as i, matchAPIRouteAtBasePath as m, normalizeRouteResponse as n, resolveAPIRouteEndpoint as r };

package/dist/schema-dev-notice-JMXEQWIQ.mjs

@@ -0,0 +1,54 @@
+import {
+  findSchemaTableOwners,
+  migrateSchemaTables
+} from "./chunk-72KABRWN.mjs";
+import "./chunk-2DLGV2ZG.mjs";
+import "./chunk-WNLPQW7W.mjs";
+import "./chunk-F3N52U7S.mjs";
+import {
+  logger
+} from "./chunk-JSDV2NUN.mjs";
+import "./chunk-H3ASZDT7.mjs";
+import "./chunk-OHWM2VI4.mjs";
+import "./chunk-AYP2YFVN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/schema-dev-notice.ts
+async function noticePendingSchemaChanges(config, options = {}) {
+  const lines = [];
+  try {
+    const owners = findSchemaTableOwners(config);
+    const timeoutMs = options.timeoutMs ?? 5e3;
+    for (const owner of owners) {
+      try {
+        const result = await withTimeout(
+          migrateSchemaTables(owner, { config, log: () => {
+          } }),
+          timeoutMs
+        );
+        if (result.planned === 0) continue;
+        const { from, to } = result.upgrade ?? {};
+        const name = from && to && from !== to ? `${owner.name} ${from} \u2192 ${to}` : owner.name;
+        lines.push(
+          `${name} has ${result.planned} change(s) to its tables that are not applied yet. Run \`farm ${owner.name} migrate\` to review them.`
+        );
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const log = options.log ?? ((message) => logger.warn(message));
+  for (const line of lines) log(line);
+  return lines;
+}
+function withTimeout(work, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("timed out")), timeoutMs);
+    timer.unref?.();
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+export {
+  noticePendingSchemaChanges
+};

package/dist/schema-dev-notice-PLBFDTOF.cjs

@@ -0,0 +1,54 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunk5OJVKXFVcjs = require('./chunk-5OJVKXFV.cjs');
+require('./chunk-SYW346ZN.cjs');
+require('./chunk-SHD265HW.cjs');
+require('./chunk-GBMWLDCC.cjs');
+
+
+var _chunkQMNWKQL4cjs = require('./chunk-QMNWKQL4.cjs');
+require('./chunk-SUCDVKUB.cjs');
+require('./chunk-6CTFVBAT.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+// src/schema-dev-notice.ts
+async function noticePendingSchemaChanges(config, options = {}) {
+  const lines = [];
+  try {
+    const owners = _chunk5OJVKXFVcjs.findSchemaTableOwners.call(void 0, config);
+    const timeoutMs = _nullishCoalesce(options.timeoutMs, () => ( 5e3));
+    for (const owner of owners) {
+      try {
+        const result = await withTimeout(
+          _chunk5OJVKXFVcjs.migrateSchemaTables.call(void 0, owner, { config, log: () => {
+          } }),
+          timeoutMs
+        );
+        if (result.planned === 0) continue;
+        const { from, to } = _nullishCoalesce(result.upgrade, () => ( {}));
+        const name = from && to && from !== to ? `${owner.name} ${from} \u2192 ${to}` : owner.name;
+        lines.push(
+          `${name} has ${result.planned} change(s) to its tables that are not applied yet. Run \`farm ${owner.name} migrate\` to review them.`
+        );
+      } catch (e) {
+      }
+    }
+  } catch (e2) {
+  }
+  const log = _nullishCoalesce(options.log, () => ( ((message) => _chunkQMNWKQL4cjs.logger.warn(message))));
+  for (const line of lines) log(line);
+  return lines;
+}
+function withTimeout(work, timeoutMs) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error("timed out")), timeoutMs);
+    _optionalChain([timer, 'access', _2 => _2.unref, 'optionalCall', _3 => _3()]);
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+
+
+exports.noticePendingSchemaChanges = noticePendingSchemaChanges;

package/dist/schema.cjs

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkG643DQCHcjs = require('./chunk-G643DQCH.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunkZXK2EYQWcjs = require('./chunk-ZXK2EYQW.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
-exports.defineSchema = _chunkG643DQCHcjs.defineSchema;
+exports.defineSchema = _chunkZXK2EYQWcjs.defineSchema;

package/dist/schema.d.mts

@@ -0,0 +1,115 @@
+/**
+ * Farm's declarative data schema: a serializable description of models and
+ * fields shared by integrations, applications, ORM generation, and any feature
+ * that needs one schema story across storage targets.
+ *
+ * The shape is plain data, not code, so it can be inspected at build time,
+ * mapped onto an ORM schema, and serialized to other tooling.
+ */
+type FarmSchemaFieldType = "id" | "uuid" | "string" | "text" | "boolean" | "integer" | "number" | "datetime" | "json" | "enum";
+interface FarmSchemaReference {
+    model: string;
+    field: string;
+    relation?: "belongsTo" | "hasOne" | "hasMany";
+    onDelete?: "cascade" | "restrict" | "setNull" | "noAction";
+    enforced?: "db" | "app" | "none";
+}
+interface FarmSchemaField {
+    type: FarmSchemaFieldType;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    list?: boolean;
+    default?: unknown;
+    values?: readonly string[];
+    reference?: FarmSchemaReference;
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaConstraint {
+    type: "unique" | "index";
+    fields: readonly string[];
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModel {
+    name?: string;
+    description?: string;
+    /**
+     * A table someone else creates, such as the app's or an auth library's
+     * `user`. It is described so references to it resolve to its real name, and
+     * so queries can read it, but Farm never creates it: migrate, generated ORM
+     * schemas, and conflict checks skip it.
+     */
+    external?: boolean;
+    fields: Record<string, FarmSchemaField>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModelExtension {
+    name?: string;
+    description?: string;
+    fields?: Record<string, FarmSchemaField>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModelOverride {
+    name?: string;
+    description?: string;
+    fields?: Record<string, Partial<FarmSchemaField>>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchema {
+    models: Record<string, FarmSchemaModel>;
+    meta?: Record<string, unknown>;
+    extend?: Record<string, FarmSchemaModelExtension>;
+    override?: Record<string, FarmSchemaModelOverride>;
+}
+/** App-level rules for the tables plugins and integrations declare. */
+interface FarmSchemaConfig {
+    /**
+     * Tables a plugin may add columns to, keyed by the plugin's migrate name.
+     * List the plugin's model names (`user`) or your real table names
+     * (`members_auth`). Without an entry, `farm <plugin> migrate` prints the
+     * `ALTER TABLE` and refuses to run it.
+     *
+     * ```ts
+     * schema: { allowExtend: { loyalty: ["user"] } }
+     * ```
+     */
+    allowExtend?: Record<string, readonly string[]>;
+    /**
+     * A plugin's existing tables that may get foreign keys to other plugins'
+     * tables, keyed by the plugin's migrate name. Tables created from now on
+     * get them automatically; an existing table may hold rows that point at
+     * nothing, so Farm checks for those first and adds the key only when allowed.
+     *
+     * ```ts
+     * schema: { allowForeignKeys: { billing: ["subscription"] } }
+     * ```
+     */
+    allowForeignKeys?: Record<string, readonly string[]>;
+}
+/**
+ * Declare a data schema with full type inference preserved.
+ *
+ * ```ts
+ * export const schema = defineSchema({
+ *   models: {
+ *     tasks: {
+ *       fields: {
+ *         id: { type: "uuid", primaryKey: true },
+ *         title: { type: "string", required: true },
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function defineSchema<TSchema extends FarmSchema>(schema: TSchema): TSchema;
+
+export { type FarmSchema, type FarmSchemaConfig, type FarmSchemaConstraint, type FarmSchemaField, type FarmSchemaFieldType, type FarmSchemaModel, type FarmSchemaModelExtension, type FarmSchemaModelOverride, type FarmSchemaReference, defineSchema };

package/dist/schema.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Farm's declarative data schema: a serializable description of models and
+ * fields shared by integrations, applications, ORM generation, and any feature
+ * that needs one schema story across storage targets.
+ *
+ * The shape is plain data, not code, so it can be inspected at build time,
+ * mapped onto an ORM schema, and serialized to other tooling.
+ */
+type FarmSchemaFieldType = "id" | "uuid" | "string" | "text" | "boolean" | "integer" | "number" | "datetime" | "json" | "enum";
+interface FarmSchemaReference {
+    model: string;
+    field: string;
+    relation?: "belongsTo" | "hasOne" | "hasMany";
+    onDelete?: "cascade" | "restrict" | "setNull" | "noAction";
+    enforced?: "db" | "app" | "none";
+}
+interface FarmSchemaField {
+    type: FarmSchemaFieldType;
+    name?: string;
+    description?: string;
+    required?: boolean;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    unique?: boolean;
+    index?: boolean;
+    list?: boolean;
+    default?: unknown;
+    values?: readonly string[];
+    reference?: FarmSchemaReference;
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaConstraint {
+    type: "unique" | "index";
+    fields: readonly string[];
+    name?: string;
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModel {
+    name?: string;
+    description?: string;
+    /**
+     * A table someone else creates, such as the app's or an auth library's
+     * `user`. It is described so references to it resolve to its real name, and
+     * so queries can read it, but Farm never creates it: migrate, generated ORM
+     * schemas, and conflict checks skip it.
+     */
+    external?: boolean;
+    fields: Record<string, FarmSchemaField>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModelExtension {
+    name?: string;
+    description?: string;
+    fields?: Record<string, FarmSchemaField>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchemaModelOverride {
+    name?: string;
+    description?: string;
+    fields?: Record<string, Partial<FarmSchemaField>>;
+    constraints?: readonly FarmSchemaConstraint[];
+    meta?: Record<string, unknown>;
+}
+interface FarmSchema {
+    models: Record<string, FarmSchemaModel>;
+    meta?: Record<string, unknown>;
+    extend?: Record<string, FarmSchemaModelExtension>;
+    override?: Record<string, FarmSchemaModelOverride>;
+}
+/** App-level rules for the tables plugins and integrations declare. */
+interface FarmSchemaConfig {
+    /**
+     * Tables a plugin may add columns to, keyed by the plugin's migrate name.
+     * List the plugin's model names (`user`) or your real table names
+     * (`members_auth`). Without an entry, `farm <plugin> migrate` prints the
+     * `ALTER TABLE` and refuses to run it.
+     *
+     * ```ts
+     * schema: { allowExtend: { loyalty: ["user"] } }
+     * ```
+     */
+    allowExtend?: Record<string, readonly string[]>;
+    /**
+     * A plugin's existing tables that may get foreign keys to other plugins'
+     * tables, keyed by the plugin's migrate name. Tables created from now on
+     * get them automatically; an existing table may hold rows that point at
+     * nothing, so Farm checks for those first and adds the key only when allowed.
+     *
+     * ```ts
+     * schema: { allowForeignKeys: { billing: ["subscription"] } }
+     * ```
+     */
+    allowForeignKeys?: Record<string, readonly string[]>;
+}
+/**
+ * Declare a data schema with full type inference preserved.
+ *
+ * ```ts
+ * export const schema = defineSchema({
+ *   models: {
+ *     tasks: {
+ *       fields: {
+ *         id: { type: "uuid", primaryKey: true },
+ *         title: { type: "string", required: true },
+ *       },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function defineSchema<TSchema extends FarmSchema>(schema: TSchema): TSchema;
+
+export { type FarmSchema, type FarmSchemaConfig, type FarmSchemaConstraint, type FarmSchemaField, type FarmSchemaFieldType, type FarmSchemaModel, type FarmSchemaModelExtension, type FarmSchemaModelOverride, type FarmSchemaReference, defineSchema };

package/dist/schema.mjs

@@ -1,7 +1,7 @@
 import {
   defineSchema
-} from "./chunk-44SYJEG3.mjs";
-import "./chunk-LPEX4YW6.mjs";
+} from "./chunk-46P5KNTE.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   defineSchema
 };

package/dist/search-client-OXH6GBNO.mjs

@@ -0,0 +1,15 @@
+import {
+  generateFarmDocsSearchBootstrapRuntime,
+  generateFarmDocsSearchClientRuntime,
+  isFarmDocsSearchEnabled,
+  resolveFarmDocsSearchClientModule,
+  resolveFarmDocsSearchFrameworkModule
+} from "./chunk-ALEUMLJN.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  generateFarmDocsSearchBootstrapRuntime,
+  generateFarmDocsSearchClientRuntime,
+  isFarmDocsSearchEnabled,
+  resolveFarmDocsSearchClientModule,
+  resolveFarmDocsSearchFrameworkModule
+};

package/dist/search-client-ZZLKVO5R.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+var _chunkDZZHTMWMcjs = require('./chunk-DZZHTMWM.cjs');
+require('./chunk-BTZ5O6VM.cjs');
+
+
+
+
+
+
+exports.generateFarmDocsSearchBootstrapRuntime = _chunkDZZHTMWMcjs.generateFarmDocsSearchBootstrapRuntime; exports.generateFarmDocsSearchClientRuntime = _chunkDZZHTMWMcjs.generateFarmDocsSearchClientRuntime; exports.isFarmDocsSearchEnabled = _chunkDZZHTMWMcjs.isFarmDocsSearchEnabled; exports.resolveFarmDocsSearchClientModule = _chunkDZZHTMWMcjs.resolveFarmDocsSearchClientModule; exports.resolveFarmDocsSearchFrameworkModule = _chunkDZZHTMWMcjs.resolveFarmDocsSearchFrameworkModule;

package/dist/server-action-security.cjs

@@ -10,12 +10,13 @@
 
 
 
-var _chunkT5OJPTVNcjs = require('./chunk-T5OJPTVN.cjs');
-require('./chunk-SVRTJOUF.cjs');
-require('./chunk-KIIMAWOJ.cjs');
-require('./chunk-ZEG3OPIB.cjs');
-require('./chunk-NO3WWW3N.cjs');
-require('./chunk-S3JO3N4H.cjs');
+var _chunk4P5634G6cjs = require('./chunk-4P5634G6.cjs');
+require('./chunk-FEFCISOX.cjs');
+require('./chunk-CFG4QERR.cjs');
+require('./chunk-JYT7AN37.cjs');
+require('./chunk-UZCMMJJT.cjs');
+require('./chunk-YTVSWXEZ.cjs');
+require('./chunk-BTZ5O6VM.cjs');
 
 
 
@@ -28,4 +29,4 @@ require('./chunk-S3JO3N4H.cjs');
 
 
 
-exports.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = _chunkT5OJPTVNcjs.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT; exports.ServerActionRequestError = _chunkT5OJPTVNcjs.ServerActionRequestError; exports.createServerActionRequestErrorResponse = _chunkT5OJPTVNcjs.createServerActionRequestErrorResponse; exports.getServerActionExecutionContext = _chunkT5OJPTVNcjs.getServerActionExecutionContext; exports.getServerActionInvalidations = _chunkT5OJPTVNcjs.getServerActionInvalidations; exports.getServerActionSignal = _chunkT5OJPTVNcjs.getServerActionSignal; exports.prepareServerActionRequest = _chunkT5OJPTVNcjs.prepareServerActionRequest; exports.resolveServerActionsConfig = _chunkT5OJPTVNcjs.resolveServerActionsConfig; exports.runWithServerActionRequest = _chunkT5OJPTVNcjs.runWithServerActionRequest; exports.sanitizeServerActionError = _chunkT5OJPTVNcjs.sanitizeServerActionError; exports.validateServerActionRequest = _chunkT5OJPTVNcjs.validateServerActionRequest;
+exports.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = _chunk4P5634G6cjs.DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT; exports.ServerActionRequestError = _chunk4P5634G6cjs.ServerActionRequestError; exports.createServerActionRequestErrorResponse = _chunk4P5634G6cjs.createServerActionRequestErrorResponse; exports.getServerActionExecutionContext = _chunk4P5634G6cjs.getServerActionExecutionContext; exports.getServerActionInvalidations = _chunk4P5634G6cjs.getServerActionInvalidations; exports.getServerActionSignal = _chunk4P5634G6cjs.getServerActionSignal; exports.prepareServerActionRequest = _chunk4P5634G6cjs.prepareServerActionRequest; exports.resolveServerActionsConfig = _chunk4P5634G6cjs.resolveServerActionsConfig; exports.runWithServerActionRequest = _chunk4P5634G6cjs.runWithServerActionRequest; exports.sanitizeServerActionError = _chunk4P5634G6cjs.sanitizeServerActionError; exports.validateServerActionRequest = _chunk4P5634G6cjs.validateServerActionRequest;

package/dist/server-action-security.d.mts

@@ -0,0 +1,45 @@
+import { S as SerializedServerFnFailure } from './server-fn-error.d-DrcH9cc1.mjs';
+
+declare const DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1000000;
+interface FarmServerActionsConfig {
+    /** Additional trusted origins or host patterns, such as https://app.example.com. */
+    allowedOrigins?: readonly string[];
+    /** Maximum encoded request body size in bytes or as a size string such as "1mb". */
+    bodySizeLimit?: number | string;
+}
+interface ResolvedFarmServerActionsConfig {
+    allowedOrigins: readonly string[];
+    bodySizeLimit: number;
+}
+type ServerActionRequestKind = "javascript" | "form";
+interface PreparedServerActionRequest {
+    body: string | FormData;
+    contentType: string;
+}
+type SanitizedServerActionError = {
+    name: "ServerActionError";
+    message: "Server function failed";
+} | SerializedServerFnFailure;
+type ServerActionRequestErrorCode = "BODY_TOO_LARGE" | "INVALID_ACTION_ID" | "INVALID_BODY" | "INVALID_CONTENT_LENGTH" | "INVALID_METHOD" | "INVALID_ORIGIN" | "MISSING_ORIGIN" | "UNSUPPORTED_CONTENT_TYPE";
+declare class ServerActionRequestError extends Error {
+    readonly code: ServerActionRequestErrorCode;
+    readonly status: number;
+    constructor(code: ServerActionRequestErrorCode, status: number, message: string);
+}
+type ServerActionExecutionContext = {
+    request: Request;
+    signal: AbortSignal;
+    invalidations: Set<string>;
+    cacheTasks: Set<Promise<void>>;
+};
+declare function resolveServerActionsConfig(config: FarmServerActionsConfig | undefined): ResolvedFarmServerActionsConfig;
+declare function validateServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig): void;
+declare function prepareServerActionRequest(request: Request, config: ResolvedFarmServerActionsConfig, kind: ServerActionRequestKind, actionId?: string | null): Promise<PreparedServerActionRequest>;
+declare function createServerActionRequestErrorResponse(error: unknown): Response | null;
+declare function sanitizeServerActionError(error: unknown): SanitizedServerActionError;
+declare function runWithServerActionRequest<T>(request: Request, callback: () => T | Promise<T>): Promise<T>;
+declare function getServerActionExecutionContext(): ServerActionExecutionContext | undefined;
+declare function getServerActionSignal(): AbortSignal;
+declare function getServerActionInvalidations(): readonly string[];
+
+export { DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT, type FarmServerActionsConfig, type PreparedServerActionRequest, type ResolvedFarmServerActionsConfig, type SanitizedServerActionError, ServerActionRequestError, type ServerActionRequestKind, createServerActionRequestErrorResponse, getServerActionExecutionContext, getServerActionInvalidations, getServerActionSignal, prepareServerActionRequest, resolveServerActionsConfig, runWithServerActionRequest, sanitizeServerActionError, validateServerActionRequest };