@rebasepro/server 0.24.0 → 0.24.1-canary.g56af4a4

package/dist/load-failure-UvzZgGXT.js

@@ -0,0 +1,48 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+import * as path$1 from "path";
+//#region src/utils/dynamic-import.ts
+/**
+* Native ESM dynamic import.
+*
+* Wrapped in `new Function` so TypeScript / bundlers don't down-compile the
+* `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`
+* files at runtime using the host's real ESM loader. This is the production
+* default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.
+*
+* @internal
+*/
+var nativeDynamicImport = (() => {
+	const doImport = new Function("url", "return import(url)");
+	return (url) => doImport(url);
+})();
+//#endregion
+//#region src/utils/load-failure.ts
+/**
+* How a function or cron file that failed to import is listed in the boot
+* log: `"<file> (syntax error at <file>:<line>: <message>)"` for a syntax
+* error, `"<file> (threw: <message>)"` for anything else.
+*
+* The two need different remedies. A file that *threw* usually read an
+* undefined env var at module scope; a file with a *syntax error* needs its
+* syntax fixed, and the loaders' advice is keyed on which one this is. Node
+* puts a syntax error's location only in the first line of its stack, so that
+* is where the line number comes from.
+*/
+function describeLoadFailure(file, err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (err instanceof Error && err.name === "SyntaxError") {
+		const firstLine = err.stack?.split("\n", 1)[0] ?? "";
+		const at = /:(\d+)(?::\d+)?$/.exec(firstLine);
+		return `${file} (syntax error${at ? ` at ${path$1.basename(file)}:${at[1]}` : ""}: ${message})`;
+	}
+	return `${file} (threw: ${message})`;
+}
+/** The advice for {@link describeLoadFailure}'s syntax-error entries. */
+var SYNTAX_ERROR_ADVICE = "  A file with a syntax error never ran: fix the syntax at the line shown (`tsc --noEmit` or your editor will point at it too).";
+//#endregion
+export { describeLoadFailure as n, nativeDynamicImport as r, SYNTAX_ERROR_ADVICE as t };
+
+//# sourceMappingURL=load-failure-UvzZgGXT.js.map

package/dist/load-failure-UvzZgGXT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-failure-UvzZgGXT.js","names":[],"sources":["../src/utils/dynamic-import.ts","../src/utils/load-failure.ts"],"sourcesContent":["/**\n * Shape returned by a dynamic module import: an object whose `default`\n * property holds the module's default export (CJS `module.exports` is exposed\n * as `default` by Node's ESM interop).\n */\nexport interface ImportedModule {\n    default?: unknown;\n    [key: string]: unknown;\n}\n\n/**\n * Imports a module by file URL. Injected into the directory loaders so tests\n * can supply a deterministic importer.\n */\nexport type ModuleImporter = (url: string) => Promise<ImportedModule>;\n\n/**\n * Native ESM dynamic import.\n *\n * Wrapped in `new Function` so TypeScript / bundlers don't down-compile the\n * `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`\n * files at runtime using the host's real ESM loader. This is the production\n * default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.\n *\n * @internal\n */\nexport const nativeDynamicImport: ModuleImporter = (() => {\n    const doImport = new Function(\"url\", \"return import(url)\") as (url: string) => Promise<ImportedModule>;\n    return (url: string) => doImport(url);\n})();\n","import * as path from \"path\";\n\n/**\n * How a function or cron file that failed to import is listed in the boot\n * log: `\"<file> (syntax error at <file>:<line>: <message>)\"` for a syntax\n * error, `\"<file> (threw: <message>)\"` for anything else.\n *\n * The two need different remedies. A file that *threw* usually read an\n * undefined env var at module scope; a file with a *syntax error* needs its\n * syntax fixed, and the loaders' advice is keyed on which one this is. Node\n * puts a syntax error's location only in the first line of its stack, so that\n * is where the line number comes from.\n */\nexport function describeLoadFailure(file: string, err: unknown): string {\n    const message = err instanceof Error ? err.message : String(err);\n    // By name, not `instanceof`: the error comes from whatever realm did the\n    // import, and its SyntaxError is not this one's.\n    if (err instanceof Error && err.name === \"SyntaxError\") {\n        const firstLine = err.stack?.split(\"\\n\", 1)[0] ?? \"\";\n        const at = /:(\\d+)(?::\\d+)?$/.exec(firstLine);\n        const where = at ? ` at ${path.basename(file)}:${at[1]}` : \"\";\n        return `${file} (syntax error${where}: ${message})`;\n    }\n    return `${file} (threw: ${message})`;\n}\n\n/** The advice for {@link describeLoadFailure}'s syntax-error entries. */\nexport const SYNTAX_ERROR_ADVICE =\n    \"  A file with a syntax error never ran: fix the syntax at the line shown \" +\n    \"(`tsc --noEmit` or your editor will point at it too).\";\n"],"mappings":";;;;;;;;;;;;;;;;AA0BA,IAAa,6BAA6C;CACtD,MAAM,WAAW,IAAI,SAAS,OAAO,oBAAoB;CACzD,QAAQ,QAAgB,SAAS,GAAG;AACxC,EAAA,CAAG;;;;;;;;;;;;;;AChBH,SAAgB,oBAAoB,MAAc,KAAsB;CACpE,MAAM,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;CAG/D,IAAI,eAAe,SAAS,IAAI,SAAS,eAAe;EACpD,MAAM,YAAY,IAAI,OAAO,MAAM,MAAM,CAAC,CAAC,CAAC,MAAM;EAClD,MAAM,KAAK,mBAAmB,KAAK,SAAS;EAE5C,OAAO,GAAG,KAAK,gBADD,KAAK,OAAO,OAAK,SAAS,IAAI,EAAE,GAAG,GAAG,OAAO,GACtB,IAAI,QAAQ;CACrD;CACA,OAAO,GAAG,KAAK,WAAW,QAAQ;AACtC;;AAGA,IAAa,sBACT"}

package/dist/mcp/mcp-tools.d.ts

@@ -51,6 +51,14 @@ export interface McpToolDefinition {
      * to be listed, and on the collection a call names for it to run.
      */
     requiredScope: McpScope;
+    /**
+     * Whether the reply carries the result a second time, as
+     * `structuredContent`. The text block always carries it — it is what a
+     * model reads. A result a program consumes (rows, a count, a write's
+     * outcome) also goes out as typed data; one only a model reads does not,
+     * so the reply is not twice its size. Defaults to true.
+     */
+    structuredContent?: boolean;
     run(args: Record<string, unknown>, ctx: McpToolContext): Promise<unknown>;
 }
 /** An error whose message is safe to hand back to the model. */

package/dist/metrics/index.d.ts

@@ -31,11 +31,24 @@ export type MetricSurface = "data" | "auth" | "storage" | "functions" | "admin"
  | "other";
 /** Whether a path is the platform looking in, rather than a request served. */
 export declare function isUncountedPath(pathname: string): boolean;
+/**
+ * How long a query waited for a pooled database connection, in milliseconds —
+ * opening one included, when the pool had to. Labelled by data source. See
+ * `pool-wait.ts`, which records it, and why it matters there.
+ */
+export declare const DB_POOL_WAIT_METRIC = "rebase_db_pool_wait_ms";
+/**
+ * Buckets for {@link DB_POOL_WAIT_METRIC}. A checkout from a pool with an idle
+ * connection takes well under a millisecond, so the low end is finer than a
+ * request's: the interesting number is how much of the tail is above zero.
+ */
+export declare const POOL_WAIT_BUCKETS_MS: number[];
 export declare class MetricsRegistry {
     private requests;
     private latency;
     private gauges;
     private counters;
+    private histograms;
     readonly startedAt: number;
     private static labelKey;
     private static parseLabels;
@@ -51,6 +64,11 @@ export declare class MetricsRegistry {
     recordRequest(labels: Record<string, string>, durationMs: number): void;
     incrementCounter(name: string, labels?: Record<string, string>, by?: number): void;
     setGauge(name: string, value: number, labels?: Record<string, string>): void;
+    /**
+     * Record one observation in a named histogram. `buckets` are its upper
+     * bounds, fixed by the first observation of the series.
+     */
+    observe(name: string, value: number, labels?: Record<string, string>, buckets?: readonly number[]): void;
     /** Prometheus escaping: backslash, quote and newline, in that order. */
     private static formatLabels;
     /** Group `name -> [[labelKey, value]]` for one-HELP-per-metric rendering. */

package/dist/metrics/pool-wait.d.ts

@@ -0,0 +1,50 @@
+/**
+ * How long queries wait for a pooled database connection.
+ *
+ * A write holds its connection — and its transaction, and the locks it has
+ * taken — for as long as its callbacks run: `beforeSave` runs after the
+ * transaction has begun, `afterSave` before it commits. Callbacks that await
+ * something slow therefore take connections out of the pool for that long, and
+ * once enough of them run at once every other request queues for one. Measured
+ * with the default pool of 20: 25 concurrent saves whose `beforeSave` awaited
+ * 300 ms made an unrelated one-row read wait 290 ms for a connection.
+ *
+ * Nothing else shows that queue. Request latency rises, but so it does for a
+ * slow query; this histogram says how much of a request was spent waiting for
+ * a connection at all. Near zero is a healthy pool.
+ *
+ * @module
+ */
+import { type MetricsRegistry } from "./index.js";
+/** `pg.Pool`'s callback form of `connect`, which `pool.query` uses internally. */
+type ConnectCallback = (err: Error | undefined, client: unknown, done: (release?: unknown) => void) => void;
+/**
+ * `connect` as a `pg.Pool` has it: a promise without a callback, the callback
+ * with one. Both are timed — transactions check out with the first,
+ * `pool.query` with the second.
+ */
+export type PoolConnect = (callback?: ConnectCallback) => Promise<unknown> | void;
+/**
+ * Time every checkout from `pool`, from the call to the moment a connection is
+ * handed over, and report it to `record` in milliseconds. A failed checkout is
+ * not recorded: it is an error, not a wait.
+ *
+ * Wraps `connect` on this pool object only. `false` when the pool has no
+ * `connect` to time (a driver that is not pool-based) or is timed already.
+ */
+export declare function timePoolCheckouts(pool: {
+    connect?: PoolConnect;
+}, record: (waitMs: number) => void): boolean;
+/**
+ * Time the checkouts of every pool-based data source into `registry`'s
+ * {@link DB_POOL_WAIT_METRIC} histogram, labelled by the source's key.
+ */
+export declare function recordPoolWaits(registry: MetricsRegistry, sources: readonly {
+    key: string;
+    connection: {
+        pool?: {
+            connect?: PoolConnect;
+        };
+    };
+}[]): void;
+export {};