dirsql 0.4.46 → 0.4.48

package/dist/cli/resolve-config-extensions.js

@@ -1,17 +1,17 @@
 // Launcher-side resolution of the TOML configs' `[[dirsql.extension]]` entries.
 //
-// The compiled `dirsql` binary loads config extensions literally — it has no
-// `require.resolve`, so it cannot resolve a bare **package name**. When any
-// TOML config in argv names an extension by package name, the shared SDK
-// resolver resolves every config's entries and this launcher passes the
-// resolved literal paths to the binary via repeatable `--extension` flags;
-// the binary then loads those and ignores the configs' own extension entries.
+// The core loads config extensions literally — it has no `require.resolve`,
+// so it cannot resolve a bare **package name**. When any TOML config in argv
+// names an extension by package name, the shared SDK resolver resolves every
+// config's entries and this launcher passes the resolved literal paths on via
+// repeatable `--extension` flags; the core then loads those and ignores the
+// configs' own extension entries.
 //
 // Native-language configs (`.py`/`.js`/`.mjs`/`.cjs`) are untouched: the binary
 // dispatches those to `dirsql interpret`, whose handshake already carries
 // resolved paths.
-import { existsSync } from "node:fs";
 import { getCore } from "../core.js";
+import { resolveConfigsExtensionSpecs } from "../resolve-config-extensions.js";
 // Config extensions the binary dispatches to `dirsql interpret`; never
 // pre-resolved here (that path resolves via the handshake).
 const NATIVE_CONFIG_SUFFIXES = [".py", ".js", ".mjs", ".cjs"];
@@ -28,14 +28,6 @@ export async function withResolvedExtensions(argv) {
     const configPaths = getCore()
         .configPathsFromArgv(argv)
         .filter((p) => !NATIVE_CONFIG_SUFFIXES.some((s) => p.endsWith(s)));
-    // The shared resolver pulls in smol-toml, which only a TOML config on disk
-    // can need. Guarding on the same `existsSync` the resolver itself starts
-    // with keeps the parser off the common launch path entirely (#720); the
-    // resolver skips any individually-missing config on its own.
-    if (!configPaths.some((p) => existsSync(p))) {
-        return argv;
-    }
-    const { resolveConfigsExtensionSpecs } = await import("../resolve-config-extensions.js");
     const specs = resolveConfigsExtensionSpecs(configPaths);
     if (specs === null) {
         return argv;

package/dist/core.d.ts

@@ -10,8 +10,32 @@ export interface NativeDirSQL {
 export interface NativeDirSQLConstructor {
     openAsync(root: string | null, tables: TableDef[] | null, ignore: string[] | null, config: string[] | null, persist: boolean | null, persistPath: string | null, extensions: ExtensionSpec[] | null, suppressConfigExtensions: boolean | null, noIgnore: boolean | null): Promise<NativeDirSQL>;
 }
+export interface ConfigSource {
+    path: string;
+    contents?: string;
+}
+/** One planned `[[dirsql.extension]]` entry, as the core plans it.
+ *
+ * Exactly one of `path` and `package` is set: a `path` is ready to load, a
+ * `package` must be located with `require.resolve` first — unless `shadow`
+ * names an existing file, which takes precedence over the package.
+ */
+export type ExtensionPlanEntry = {
+    path: string;
+    package?: undefined;
+    shadow?: undefined;
+    entrypoint?: string;
+} | {
+    path?: undefined;
+    package: string;
+    shadow: string;
+    entrypoint?: string;
+};
 export interface CoreModule {
     DirSQL: NativeDirSQLConstructor;
     configPathsFromArgv(argv: string[]): string[];
+    planConfigExtensions(configs: ConfigSource[]): ExtensionPlanEntry[] | null;
+    selectLoadable(name: string, dirs: string[], candidates: string[]): string;
+    planExtensionPath(path: string, base: string, resolveRelative: boolean): ExtensionPlanEntry;
 }
 export declare function getCore(): CoreModule;

package/dist/plan-entry-path.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionPlanEntry } from "./core.js";
+import type { PackageResolver } from "./package-dir.js";
+/** Resolve a planned entry to a concrete file.
+ *
+ * A literal entry is already resolved. A package entry prefers a same-named
+ * file shadowing it next to the config, then the installed package.
+ */
+export declare function planEntryPath(entry: ExtensionPlanEntry, resolver?: PackageResolver): string;

package/dist/plan-entry-path.js

@@ -0,0 +1,18 @@
+// The loadable path one planned extension entry resolves to.
+import { existsSync, statSync } from "node:fs";
+import { defaultResolver } from "./default-resolver.js";
+import { resolvePackage } from "./resolve-package.js";
+/** Resolve a planned entry to a concrete file.
+ *
+ * A literal entry is already resolved. A package entry prefers a same-named
+ * file shadowing it next to the config, then the installed package.
+ */
+export function planEntryPath(entry, resolver = defaultResolver()) {
+    if (entry.path !== undefined) {
+        return entry.path;
+    }
+    if (existsSync(entry.shadow) && statSync(entry.shadow).isFile()) {
+        return entry.shadow;
+    }
+    return resolvePackage(entry.package, resolver);
+}

package/dist/read-config.d.ts

@@ -0,0 +1,5 @@
+/** The config's text, or `undefined` when it cannot be read.
+ *
+ * A missing or unreadable config is left for the core to report.
+ */
+export declare function readConfig(configPath: string): string | undefined;

package/dist/read-config.js

@@ -0,0 +1,12 @@
+// Reading one TOML config off disk for the core's extension planner.
+import { readFileSync } from "node:fs";
+/** The config's text, or `undefined` when it cannot be read.
+ *
+ * A missing or unreadable config is left for the core to report.
+ */
+export function readConfig(configPath) {
+    try {
+        return readFileSync(configPath, "utf8");
+    }
+    catch { }
+}

package/dist/resolve-config-extensions.js

@@ -1,15 +1,16 @@
-// SDK-side resolution of a TOML config's `[[dirsql.extension]]` entries.
+// SDK-side resolution of the TOML configs' `[[dirsql.extension]]` entries.
 //
-// The Rust core loads config extensions literally — it has no
-// `require.resolve`, so it cannot resolve a bare **package name**. When a
-// config names an extension by package name, the SDK resolves every entry
-// here, hands the core the resolved literal paths, and suppresses the core's
-// own config-extension loading so the entries are not loaded twice.
+// The planning — which configs parse, whether any entry names a package rather
+// than a file, and what each literal path resolves to against its own config's
+// directory — lives in the Rust core (`planConfigExtensions`). This module
+// supplies the two host-specific halves the core cannot have: reading the
+// files, and locating an installed package with `require.resolve`.
 //
 // Shared by the `DirSQL` constructor (`config` option) and the CLI launcher.
-import { hasBareName } from "./has-bare-name.js";
-import { loadExtensionEntries } from "./load-extension-entries.js";
-import { resolveEntries } from "./resolve-entries.js";
+import { resolve as resolvePath } from "node:path";
+import { getCore } from "./core.js";
+import { planEntryPath } from "./plan-entry-path.js";
+import { readConfig } from "./read-config.js";
 /**
  * Resolve the `[[dirsql.extension]]` entries of several configs, in order.
  *
@@ -22,15 +23,15 @@ import { resolveEntries } from "./resolve-entries.js";
  * the core.
  */
 export function resolveConfigsExtensionSpecs(configPaths) {
-    const loaded = configPaths.map(loadExtensionEntries);
-    if (!loaded.some((item) => item !== null && hasBareName(item.entries))) {
+    const plan = getCore().planConfigExtensions(configPaths.map((path) => ({
+        path: resolvePath(path),
+        contents: readConfig(path),
+    })));
+    if (plan === null) {
         return null;
     }
-    const specs = [];
-    for (const item of loaded) {
-        if (item !== null) {
-            specs.push(...resolveEntries(item.entries, item.base));
-        }
-    }
-    return specs;
+    return plan.map((entry) => ({
+        path: planEntryPath(entry),
+        entrypoint: entry.entrypoint,
+    }));
 }

package/dist/resolve-extension.js

@@ -1,6 +1,8 @@
 // Resolve an extension entry's `path` to a concrete loadable file.
 //
-// Resolution is an ordered probe (file-first, then package):
+// Resolution is an ordered probe (file-first, then package), planned by the
+// core (`planExtensionPath`) and carried out here: only locating an installed
+// package is host-specific.
 //
 //   1. Path-looking (contains a separator, or ends in `.so` / `.dylib` /
 //      `.dll` / `.node`) -> returned as a file path: made absolute against
@@ -8,14 +10,10 @@
 //      verbatim (programmatic entries).
 //   2. Bare package name -> a same-named local file under `base` shadows the
 //      package; otherwise the package dir is located via `require.resolve`
-//      and the current platform's loadable is globbed from inside it. Zero
-//      matches and multiple matches are both hard errors -- disambiguate
-//      with a literal path.
-import { existsSync, statSync } from "node:fs";
-import { isAbsolute, resolve as resolvePath } from "node:path";
+//      and the current platform's loadable is picked from inside it.
+import { getCore } from "./core.js";
 import { defaultResolver } from "./default-resolver.js";
-import { isBareName } from "./is-bare-name.js";
-import { resolvePackage } from "./resolve-package.js";
+import { planEntryPath } from "./plan-entry-path.js";
 /**
  * Resolve an extension `path` to a concrete file. `base` is the directory a
  * relative path and the bare-name shadow probe resolve against (a config file's
@@ -24,15 +22,5 @@ import { resolvePackage } from "./resolve-package.js";
  * when false it is returned verbatim (programmatic semantics).
  */
 export function resolveExtensionPath(path, base, resolveRelative, resolver = defaultResolver()) {
-    if (!isBareName(path)) {
-        if (resolveRelative && !isAbsolute(path)) {
-            return resolvePath(base, path);
-        }
-        return path;
-    }
-    const local = resolvePath(base, path);
-    if (existsSync(local) && statSync(local).isFile()) {
-        return local;
-    }
-    return resolvePackage(path, resolver);
+    return planEntryPath(getCore().planExtensionPath(path, base, resolveRelative), resolver);
 }

package/dist/resolve-package.d.ts

@@ -1,3 +1,3 @@
 import { type PackageResolver } from "./package-dir.js";
-/** Glob the platform loadable inside a bare name's package dir. */
+/** Pick the platform loadable inside a bare name's package dir. */
 export declare function resolvePackage(name: string, resolver: PackageResolver): string;

package/dist/resolve-package.js

@@ -1,22 +1,15 @@
-// Glob a bare package name's platform loadable out of its installed directory.
+// Locate a bare package name's platform loadable inside its installed dir.
+//
+// `require.resolve` finds the package's directory; the core picks the one
+// loadable file inside it (and throws on zero or several — the caller must
+// then disambiguate with a literal path).
 import { readdirSync } from "node:fs";
 import { join } from "node:path";
+import { getCore } from "./core.js";
 import { packageDir } from "./package-dir.js";
-import { platformSuffixes } from "./platform-suffixes.js";
-/** Glob the platform loadable inside a bare name's package dir. */
+/** Pick the platform loadable inside a bare name's package dir. */
 export function resolvePackage(name, resolver) {
     const dir = packageDir(name, resolver);
-    const suffixes = platformSuffixes();
-    const matches = readdirSync(dir, { recursive: true })
-        .filter((entry) => suffixes.some((s) => entry.endsWith(s)))
-        .map((entry) => join(dir, entry))
-        .sort();
-    const desc = suffixes.join(" / ");
-    if (matches.length === 0) {
-        throw new Error(`no loadable extension file (${desc}) found in package '${name}' (searched ${dir})`);
-    }
-    if (matches.length > 1) {
-        throw new Error(`multiple loadable extension files found in package '${name}': ${matches.join(", ")}; disambiguate with a literal path`);
-    }
-    return matches[0];
+    const candidates = readdirSync(dir, { recursive: true }).map((entry) => join(dir, entry));
+    return getCore().selectLoadable(name, [dir], candidates);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirsql",
-  "version": "0.4.46",
+  "version": "0.4.48",
   "description": "Ephemeral SQL index over a local directory",
   "license": "MIT",
   "repository": "https://github.com/thekevinscott/dirsql",
@@ -199,8 +199,7 @@
     }
   },
   "dependencies": {
-    "bin-shim": "^0.2.0",
-    "smol-toml": "^1.6.1"
+    "bin-shim": "^0.2.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
@@ -222,10 +221,10 @@
     ]
   },
   "optionalDependencies": {
-    "@dirsql/lib-linux-x64-gnu": "0.4.46",
-    "@dirsql/lib-linux-arm64-gnu": "0.4.46",
-    "@dirsql/lib-darwin-x64": "0.4.46",
-    "@dirsql/lib-darwin-arm64": "0.4.46",
-    "@dirsql/lib-win32-x64-msvc": "0.4.46"
+    "@dirsql/lib-linux-x64-gnu": "0.4.48",
+    "@dirsql/lib-linux-arm64-gnu": "0.4.48",
+    "@dirsql/lib-darwin-x64": "0.4.48",
+    "@dirsql/lib-darwin-arm64": "0.4.48",
+    "@dirsql/lib-win32-x64-msvc": "0.4.48"
   }
 }

package/dist/has-bare-name.d.ts

@@ -1,3 +0,0 @@
-import type { Toml } from "./load-extension-entries.js";
-/** True when some entry's `path` names an extension by bare package name. */
-export declare function hasBareName(entries: Toml[]): boolean;

package/dist/has-bare-name.js

@@ -1,5 +0,0 @@
-import { isBareName } from "./is-bare-name.js";
-/** True when some entry's `path` names an extension by bare package name. */
-export function hasBareName(entries) {
-    return entries.some((e) => typeof e.path === "string" && isBareName(e.path));
-}

package/dist/is-bare-name.d.ts

@@ -1,2 +0,0 @@
-/** True when `path` is a bare package name rather than a file path. */
-export declare function isBareName(path: string): boolean;

package/dist/is-bare-name.js

@@ -1,10 +0,0 @@
-/** True when `path` is a bare package name rather than a file path. */
-export function isBareName(path) {
-    // Suffixes that mark a value as "already a file path" (so package resolution is
-    // never attempted).
-    const loadableSuffixes = [".so", ".dylib", ".dll", ".node"];
-    if (path.includes("/") || path.includes("\\")) {
-        return false;
-    }
-    return !loadableSuffixes.some((s) => path.endsWith(s));
-}

package/dist/load-extension-entries.d.ts

@@ -1,10 +0,0 @@
-export type Toml = Record<string, any>;
-/** Load a config's `[[dirsql.extension]]` entries with its base directory.
- *
- * `null` when the config is missing, unreadable/malformed, or declares no
- * extension array — the caller leaves such configs to the core.
- */
-export declare function loadExtensionEntries(configPath: string): {
-    entries: Toml[];
-    base: string;
-} | null;

package/dist/load-extension-entries.js

@@ -1,27 +0,0 @@
-// Read a TOML config's `[[dirsql.extension]]` array off disk.
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve as resolvePath } from "node:path";
-import { parse as parseToml } from "smol-toml";
-/** Load a config's `[[dirsql.extension]]` entries with its base directory.
- *
- * `null` when the config is missing, unreadable/malformed, or declares no
- * extension array — the caller leaves such configs to the core.
- */
-export function loadExtensionEntries(configPath) {
-    if (!existsSync(configPath)) {
-        return null;
-    }
-    let doc;
-    try {
-        doc = parseToml(readFileSync(configPath, "utf8"));
-    }
-    catch {
-        // Leave a malformed config for the core to report.
-        return null;
-    }
-    const dirsql = (doc.dirsql ?? {});
-    if (!Array.isArray(dirsql.extension)) {
-        return null;
-    }
-    return { entries: dirsql.extension, base: dirname(resolvePath(configPath)) };
-}

package/dist/platform-suffixes.d.ts

@@ -1,2 +0,0 @@
-/** Loadable-file glob suffix(es) for the current platform. */
-export declare function platformSuffixes(): string[];

package/dist/platform-suffixes.js

@@ -1,10 +0,0 @@
-/** Loadable-file glob suffix(es) for the current platform. */
-export function platformSuffixes() {
-    if (process.platform === "darwin") {
-        return [".dylib", ".node"];
-    }
-    if (process.platform === "win32") {
-        return [".dll", ".node"];
-    }
-    return [".so", ".node"];
-}

package/dist/resolve-config-extension-specs.d.ts

@@ -1,13 +0,0 @@
-import type { ExtensionSpec } from "./dirsql.js";
-/**
- * Resolve a TOML config's `[[dirsql.extension]]` entries to literal paths.
- *
- * Returns the resolved specs — every entry resolved via
- * `resolveExtensionPath` against the config file's parent directory — when at
- * least one entry's `path` is a bare package name. Returns `null` when the
- * caller should not intervene: the config is missing, malformed, declares no
- * extensions, or uses only literal paths — leaving the core's own loading
- * (and error reporting) untouched. Throws if a package name cannot be
- * resolved.
- */
-export declare function resolveConfigExtensionSpecs(configPath: string): ExtensionSpec[] | null;

package/dist/resolve-config-extension-specs.js

@@ -1,21 +0,0 @@
-import { hasBareName } from "./has-bare-name.js";
-import { loadExtensionEntries } from "./load-extension-entries.js";
-import { resolveEntries } from "./resolve-entries.js";
-/**
- * Resolve a TOML config's `[[dirsql.extension]]` entries to literal paths.
- *
- * Returns the resolved specs — every entry resolved via
- * `resolveExtensionPath` against the config file's parent directory — when at
- * least one entry's `path` is a bare package name. Returns `null` when the
- * caller should not intervene: the config is missing, malformed, declares no
- * extensions, or uses only literal paths — leaving the core's own loading
- * (and error reporting) untouched. Throws if a package name cannot be
- * resolved.
- */
-export function resolveConfigExtensionSpecs(configPath) {
-    const loaded = loadExtensionEntries(configPath);
-    if (loaded === null || !hasBareName(loaded.entries)) {
-        return null;
-    }
-    return resolveEntries(loaded.entries, loaded.base);
-}

package/dist/resolve-entries.d.ts

@@ -1,4 +0,0 @@
-import type { ExtensionSpec } from "./dirsql.js";
-import type { Toml } from "./load-extension-entries.js";
-/** Resolve a config's entries to specs, against that config's own directory. */
-export declare function resolveEntries(entries: Toml[], base: string): ExtensionSpec[];

package/dist/resolve-entries.js

@@ -1,8 +0,0 @@
-import { resolveExtensionPath } from "./resolve-extension.js";
-/** Resolve a config's entries to specs, against that config's own directory. */
-export function resolveEntries(entries, base) {
-    return entries.map((e) => ({
-        path: resolveExtensionPath(e.path, base, true),
-        entrypoint: typeof e.entrypoint === "string" ? e.entrypoint : undefined,
-    }));
-}