dirsql 0.4.35__tar.gz → 0.4.37__tar.gz

{dirsql-0.4.35 → dirsql-0.4.37}/Cargo.lock

@@ -540,7 +540,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.35"
+version = "0.4.37"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -583,7 +583,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.35"
+version = "0.4.37"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.35 → dirsql-0.4.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.35
+Version: 0.4.37
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory

{dirsql-0.4.35 → dirsql-0.4.37}/dirsql/_async.py

@@ -4,7 +4,7 @@ import asyncio
 import os
 
 from dirsql._dirsql import DirSQL as _RustDirSQL
-from dirsql.resolve_config_extensions import resolve_configs_extension_specs
+from dirsql.resolve_configs_extension_specs import resolve_configs_extension_specs
 from dirsql.resolve_extension import resolve_extension_path
 
 

dirsql-0.4.37/dirsql/cli/config_paths_from_argv.py

@@ -0,0 +1,28 @@
+"""Config-path extraction from the launcher's argv.
+
+Every config flag occurrence counts -- ``-c``/``--config`` are repeatable,
+and plugin discovery injects fragments as additional ``-c`` flags -- so the
+scan collects them all, in argv order.
+"""
+
+from __future__ import annotations
+
+
+def config_paths_from_argv(argv: list[str]) -> list[str]:
+    """Every config value in argv, in order (``--config X``, ``--config=X``,
+    ``-c X``, ``-c=X``, ``-cX``), or the default when none are given."""
+    paths: list[str] = []
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a == "--config" or a == "-c":
+            # A bare trailing flag (no following value) yields "".
+            paths.append(next(iter(argv[i + 1 :]), ""))
+            i += 2
+            continue
+        if a.startswith("--config="):
+            paths.append(a[len("--config=") :])
+        elif a.startswith("-c"):
+            paths.append(a[len("-c") :].removeprefix("="))
+        i += 1
+    return paths or ["./.dirsql.toml"]

{dirsql-0.4.35 → dirsql-0.4.37}/dirsql/cli/resolve_config_extensions.py

@@ -3,14 +3,10 @@
 The compiled ``dirsql`` binary loads a config's extensions literally -- it
 has no ``importlib``, so it cannot resolve a bare **package name**. When any
 TOML config in argv names an extension by package name, the shared SDK
-resolver (:mod:`dirsql.resolve_config_extensions`) resolves every config's
-extensions 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.
-
-Every config flag occurrence counts -- ``-c``/``--config`` are repeatable,
-and plugin discovery injects fragments as additional ``-c`` flags -- so the
-scan collects them all, in argv order.
+resolver (:mod:`dirsql.resolve_configs_extension_specs`) resolves every
+config's extensions 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.
 
 Native-language configs (``.py`` / ``.js`` / ``.mjs`` / ``.cjs``) are untouched:
 the binary dispatches those to ``dirsql interpret``, whose handshake already
@@ -19,33 +15,14 @@ carries resolved paths.
 
 from __future__ import annotations
 
-from ..resolve_config_extensions import resolve_configs_extension_specs
+from ..resolve_configs_extension_specs import resolve_configs_extension_specs
+from .config_paths_from_argv import config_paths_from_argv
 
 # Config extensions the binary dispatches to `dirsql interpret`; never
 # pre-resolved here (that path resolves via the handshake).
 _NATIVE_SUFFIXES = (".py", ".js", ".mjs", ".cjs")
 
 
-def _config_paths_from_argv(argv: list[str]) -> list[str]:
-    """Every config value in argv, in order (``--config X``, ``--config=X``,
-    ``-c X``, ``-c=X``, ``-cX``), or the default when none are given."""
-    paths: list[str] = []
-    i = 0
-    while i < len(argv):
-        a = argv[i]
-        if a == "--config" or a == "-c":
-            # A bare trailing flag (no following value) yields "".
-            paths.append(next(iter(argv[i + 1 :]), ""))
-            i += 2
-            continue
-        if a.startswith("--config="):
-            paths.append(a[len("--config=") :])
-        elif a.startswith("-c"):
-            paths.append(a[len("-c") :].removeprefix("="))
-        i += 1
-    return paths or ["./.dirsql.toml"]
-
-
 def with_resolved_extensions(argv: list[str]) -> list[str]:
     """Return ``argv`` plus ``--extension`` flags when a TOML config names an
     extension by package name; otherwise return ``argv`` unchanged. Raises if a
@@ -53,7 +30,7 @@ def with_resolved_extensions(argv: list[str]) -> list[str]:
     if argv and argv[0] == "init":
         return argv
     config_paths = [
-        p for p in _config_paths_from_argv(argv) if not p.endswith(_NATIVE_SUFFIXES)
+        p for p in config_paths_from_argv(argv) if not p.endswith(_NATIVE_SUFFIXES)
     ]
     if not config_paths:
         return argv

dirsql-0.4.37/dirsql/has_bare_name.py

@@ -0,0 +1,14 @@
+"""Whether any of a config's extension entries names a package."""
+
+from __future__ import annotations
+
+from .is_bare_name import is_bare_name
+
+
+def _has_bare_name(entries):
+    return any(
+        isinstance(e, dict)
+        and isinstance(e.get("path"), str)
+        and is_bare_name(e["path"])
+        for e in entries
+    )

dirsql-0.4.37/dirsql/is_bare_name.py

@@ -0,0 +1,14 @@
+"""Whether an extension ``path`` names a package rather than a file."""
+
+import os
+
+# Suffixes that mark a value as "already a file path", so package resolution
+# is never attempted.
+_LOADABLE_SUFFIXES = (".so", ".dylib", ".dll", ".pyd")
+
+
+def is_bare_name(path):
+    """True when ``path`` is a bare package name rather than a file path."""
+    if os.sep in path or (os.altsep and os.altsep in path):
+        return False
+    return not path.endswith(_LOADABLE_SUFFIXES)

dirsql-0.4.37/dirsql/load_extension_entries.py

@@ -0,0 +1,28 @@
+"""Reading one TOML config's ``[[dirsql.extension]]`` array off disk."""
+
+from __future__ import annotations
+
+import os
+
+from .toml_module import _toml
+
+
+def _load_extension_entries(config_path):
+    """Return ``(entries, base_dir)`` for a config's ``[[dirsql.extension]]``.
+
+    ``None`` when the config is missing, unreadable/malformed, or declares no
+    extension array -- the caller should leave such configs to the core.
+    """
+    if not os.path.isfile(config_path):
+        return None
+    try:
+        with open(config_path, "rb") as f:
+            doc = _toml.load(f)
+    except (OSError, _toml.TOMLDecodeError):
+        # Leave a malformed / unreadable config for the core to report.
+        return None
+
+    entries = (doc.get("dirsql") or {}).get("extension")
+    if not isinstance(entries, list):
+        return None
+    return entries, os.path.dirname(os.path.abspath(config_path))

dirsql-0.4.37/dirsql/platform_patterns.py

@@ -0,0 +1,12 @@
+"""The loadable-file glob pattern(s) the running platform uses."""
+
+import sys
+
+
+def _platform_patterns():
+    """Loadable-file glob(s) for the current platform."""
+    if sys.platform == "darwin":
+        return ("*.dylib",)
+    if sys.platform == "win32":
+        return ("*.dll", "*.pyd")
+    return ("*.so",)

dirsql-0.4.37/dirsql/resolve_config_extensions.py

@@ -0,0 +1,39 @@
+"""SDK-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
+
+The Rust core loads a config's extensions literally -- it has no
+``importlib``, so it cannot resolve a bare **package name**. When a TOML
+config names an extension by package name, the SDK resolves every one of its
+extensions here, hands the core the resolved literal paths, and suppresses
+the core's own config-extension loading (``suppress_config_extensions``) so
+the config's entries are not loaded a second time.
+
+Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
+(which converts the resolved specs into ``--extension`` flags), both of which
+reach it through :mod:`dirsql.resolve_configs_extension_specs`.
+"""
+
+from __future__ import annotations
+
+from .has_bare_name import _has_bare_name
+from .load_extension_entries import _load_extension_entries
+from .resolve_entries import _resolve_entries
+
+
+def resolve_config_extension_specs(config_path):
+    """Resolve a TOML config's ``[[dirsql.extension]]`` entries to literal paths.
+
+    Returns a list of ``{"path", "entrypoint"}`` dicts -- every entry resolved
+    via :func:`resolve_extension_path` against the config file's parent
+    directory -- when at least one entry's ``path`` is a bare package name.
+    Returns ``None`` 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. Raises if
+    a package name cannot be resolved.
+    """
+    loaded = _load_extension_entries(config_path)
+    if loaded is None:
+        return None
+    entries, base = loaded
+    if not _has_bare_name(entries):
+        return None
+    return _resolve_entries(entries, base)

dirsql-0.4.37/dirsql/resolve_configs_extension_specs.py

@@ -0,0 +1,36 @@
+"""Resolution of several TOML configs' ``[[dirsql.extension]]`` entries, in order.
+
+The plural counterpart to :func:`dirsql.resolve_config_extensions
+.resolve_config_extension_specs`, used by the SDK constructor and the CLI
+launcher when argv carries more than one ``--config``.
+"""
+
+from __future__ import annotations
+
+from .has_bare_name import _has_bare_name
+from .load_extension_entries import _load_extension_entries
+from .resolve_entries import _resolve_entries
+
+
+def resolve_configs_extension_specs(config_paths):
+    """Resolve the ``[[dirsql.extension]]`` entries of several configs, in order.
+
+    The SDK intervenes for the whole set only when **some** config names an
+    extension by bare package name (the core can resolve neither package names
+    nor -- once globally suppressed -- the literal entries of the other
+    configs). When it intervenes it resolves **every** config's entries, each
+    against that config's own parent directory, concatenated in ``config_paths``
+    order; the caller suppresses the core's config-extension loading and passes
+    the resolved list. Returns ``None`` when no config uses a package name,
+    leaving every config's loading to the core.
+    """
+    loaded = [_load_extension_entries(p) for p in config_paths]
+    if not any(item is not None and _has_bare_name(item[0]) for item in loaded):
+        return None
+    specs = []
+    for item in loaded:
+        if item is None:
+            continue
+        entries, base = item
+        specs.extend(_resolve_entries(entries, base))
+    return specs

dirsql-0.4.37/dirsql/resolve_entries.py

@@ -0,0 +1,20 @@
+"""Resolution of one config's ``[[dirsql.extension]]`` entries to literal paths."""
+
+from __future__ import annotations
+
+from .resolve_extension import resolve_extension_path
+
+
+def _resolve_entries(entries, base):
+    specs = []
+    for e in entries:
+        entrypoint = e.get("entrypoint")
+        specs.append(
+            {
+                "path": resolve_extension_path(
+                    e["path"], base=base, resolve_relative=True
+                ),
+                "entrypoint": entrypoint if isinstance(entrypoint, str) else None,
+            }
+        )
+    return specs

dirsql-0.4.37/dirsql/resolve_extension.py

@@ -0,0 +1,38 @@
+"""Resolve an extension entry's ``path`` to a concrete loadable file.
+
+Resolution is an ordered probe (file-first, then package), so only a bare
+package name reaches the package machinery:
+
+1. **Path-looking** (contains a separator, or ends in ``.so`` / ``.dylib`` /
+   ``.dll`` / ``.pyd``) -- returned as a file path: made absolute against
+   ``base`` when ``resolve_relative`` is set (config-file entries), else
+   verbatim (programmatic entries).
+2. **Bare name** -- a same-named local file under ``base`` *shadows* the
+   package; otherwise the package dir is located via
+   :func:`importlib.util.find_spec` and the current platform's loadable is
+   globbed from inside it.
+"""
+
+import os
+
+from .is_bare_name import is_bare_name
+from .resolve_package import _resolve_package
+
+
+def resolve_extension_path(path, base, resolve_relative):
+    """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 parent dir, or the cwd for programmatic
+    entries). ``resolve_relative`` makes a relative path-looking value absolute
+    against ``base`` (config-file semantics); when false it is returned verbatim
+    (programmatic semantics).
+    """
+    if not is_bare_name(path):
+        if resolve_relative and not os.path.isabs(path):
+            return os.path.join(base, path)
+        return path
+    local = os.path.join(base, path)
+    if os.path.isfile(local):
+        return local
+    return _resolve_package(path)

dirsql-0.4.37/dirsql/resolve_package.py

@@ -0,0 +1,53 @@
+"""Location of an extension package's loadable file for this platform.
+
+Zero matches and multiple matches are both hard errors -- the caller must
+disambiguate with a literal path.
+"""
+
+import glob as _glob
+import importlib.util
+import os
+
+from .platform_patterns import _platform_patterns
+
+
+def _resolve_package(name):
+    """Locate ``name``'s package dir and glob its platform loadable file."""
+    try:
+        spec = importlib.util.find_spec(name)
+    except (ImportError, ValueError) as exc:
+        raise ValueError(
+            f"could not resolve extension package {name!r}: {exc}"
+        ) from exc
+    if spec is None:
+        raise ValueError(f"could not resolve extension package {name!r}: not installed")
+
+    dirs = list(spec.submodule_search_locations or [])
+    if not dirs and spec.origin and spec.origin not in ("built-in", "frozen"):
+        dirs.append(os.path.dirname(spec.origin))
+    if not dirs:
+        raise ValueError(
+            f"could not resolve extension package {name!r}: no package directory"
+        )
+
+    patterns = _platform_patterns()
+    matches = set()
+    for d in dirs:
+        for pat in patterns:
+            matches.update(_glob.glob(os.path.join(d, "**", pat), recursive=True))
+    found = sorted(matches)
+
+    try:
+        (single,) = found
+    except ValueError:
+        pat_desc = " / ".join(patterns)
+        if not found:
+            raise ValueError(
+                f"no loadable extension file ({pat_desc}) found in package "
+                f"{name!r} (searched {', '.join(dirs)})"
+            ) from None
+        raise ValueError(
+            f"multiple loadable extension files found in package {name!r}: "
+            f"{', '.join(found)}; disambiguate with a literal path"
+        ) from None
+    return single

dirsql-0.4.37/dirsql/toml_module.py

@@ -0,0 +1,21 @@
+"""The TOML parser this interpreter reads ``.dirsql.toml`` files with."""
+
+import sys
+from importlib import import_module
+
+
+def _load_toml_module():
+    """Return the TOML parser module for the running interpreter.
+
+    ``tomllib`` is stdlib only on 3.11+; on 3.10 the ``tomli`` backport it was
+    derived from (a version-gated dependency) provides the same surface.
+    Imported by name so a unit test can exercise both arms on any
+    interpreter -- a literal ``import tomllib`` is unreachable on 3.10 no
+    matter what ``sys.version_info`` claims.
+    """
+    if sys.version_info >= (3, 11):
+        return import_module("tomllib")
+    return import_module("tomli")
+
+
+_toml = _load_toml_module()

{dirsql-0.4.35 → dirsql-0.4.37}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.4.35"
+version = "0.4.37"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

dirsql-0.4.37/packages/python/changelog.d/2026-09-04-config-paths-from-argv-module.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **The launcher's argv config-path scan moved to its own module.** `config_paths_from_argv` now lives in `dirsql/cli/config_paths_from_argv.py`; `with_resolved_extensions` imports it. Internal reorganisation with no change to the published API or CLI behavior, mirroring the TypeScript launcher. (#1042)

dirsql-0.4.37/packages/python/changelog.d/2026-09-05-config-extension-loader-split.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **The config-extension loader split into four modules.** `_load_toml_module` (with the `_toml` binding it produces) moved to `dirsql/toml_module.py`, `_load_extension_entries` to `dirsql/load_extension_entries.py` and `_has_bare_name` to `dirsql/has_bare_name.py`; `dirsql/resolve_config_extensions.py` keeps the intervene-or-not decision, `resolve_config_extension_specs`. Every function keeps its name and behavior — internal reorganisation with no change to the published API or CLI behavior. (#1079)

dirsql-0.4.37/packages/python/changelog.d/2026-09-05-resolve-config-extensions-split.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **The config-extension resolver split into three modules.** `_resolve_entries` moved to `dirsql/resolve_entries.py` and `resolve_configs_extension_specs` to `dirsql/resolve_configs_extension_specs.py`; `dirsql/resolve_config_extensions.py` keeps the TOML loading and the single-config `resolve_config_extension_specs`. Every function keeps its name and behavior — internal reorganisation with no change to the published API or CLI behavior. (#1056)

dirsql-0.4.37/packages/python/changelog.d/2026-09-05-resolve-extension-split.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **The extension-path resolver split into four modules.** `_platform_patterns` moved to `dirsql/platform_patterns.py`, `is_bare_name` (with `_LOADABLE_SUFFIXES`) to `dirsql/is_bare_name.py`, and `_resolve_package` to `dirsql/resolve_package.py`; `dirsql/resolve_extension.py` keeps the ordered probe, `resolve_extension_path`. Every function keeps its name and behavior — internal reorganisation with no change to the published API or CLI behavior. (#1066)

dirsql-0.4.37/packages/python/e2e-attestations/claude-1056-py-ofpf9.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788571386,
+  "exit_code": 0,
+  "commit": "2b1dbcacb1960ec0e13c5fa06e58dfef012dbb45",
+  "branch": "claude/1056-py-ofpf9"
+}

dirsql-0.4.37/packages/python/e2e-attestations/claude-1066-p1-resolve-extension.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788573322,
+  "exit_code": 0,
+  "commit": "4acf00655f8ebdce4297edca6b4d01b999ddfdeb",
+  "branch": "claude/1066-p1-resolve-extension"
+}

dirsql-0.4.37/packages/python/e2e-attestations/claude-1079-p2-resolve-config-extensions.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788573708,
+  "exit_code": 0,
+  "commit": "fb7bf9e800f9d682e3b8e4b83f3d69cc8642fe69",
+  "branch": "claude/1079-p2-resolve-config-extensions"
+}

dirsql-0.4.37/packages/python/e2e-attestations/claude-tackle-1042-py12.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788565282,
+  "exit_code": 0,
+  "commit": "9257c5204b6cf9b491cf5487aedbf026c5255338",
+  "branch": "claude/tackle-1042-py12"
+}

{dirsql-0.4.35 → dirsql-0.4.37}/packages/python/testing-conventions.toml

@@ -10,7 +10,7 @@
 extra_scope = ["packages/rust/src", "packages/python/src"]
 
 [python]
-one_function_per_file = { max_lines = 16 }
+one_function_per_file = { max_lines = 12 }
 
 # Same floor as the root file, which this lane no longer reads.
 [python.coverage]

{dirsql-0.4.35 → dirsql-0.4.37}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.35"
+version = "0.4.37"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

dirsql-0.4.35/dirsql/resolve_config_extensions.py

@@ -1,126 +0,0 @@
-"""SDK-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
-
-The Rust core loads a config's extensions literally -- it has no
-``importlib``, so it cannot resolve a bare **package name**. When a TOML
-config names an extension by package name, the SDK resolves every one of its
-extensions here, hands the core the resolved literal paths, and suppresses
-the core's own config-extension loading (``suppress_config_extensions``) so
-the config's entries are not loaded a second time.
-
-Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
-(which converts the resolved specs into ``--extension`` flags).
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-from importlib import import_module
-
-from .resolve_extension import is_bare_name, resolve_extension_path
-
-
-def _load_toml_module():
-    """Return the TOML parser module for the running interpreter.
-
-    ``tomllib`` is stdlib only on 3.11+; on 3.10 the ``tomli`` backport it was
-    derived from (a version-gated dependency) provides the same surface.
-    Imported by name so a unit test can exercise both arms on any
-    interpreter -- a literal ``import tomllib`` is unreachable on 3.10 no
-    matter what ``sys.version_info`` claims.
-    """
-    if sys.version_info >= (3, 11):
-        return import_module("tomllib")
-    return import_module("tomli")
-
-
-_toml = _load_toml_module()
-
-
-def _load_extension_entries(config_path):
-    """Return ``(entries, base_dir)`` for a config's ``[[dirsql.extension]]``.
-
-    ``None`` when the config is missing, unreadable/malformed, or declares no
-    extension array -- the caller should leave such configs to the core.
-    """
-    if not os.path.isfile(config_path):
-        return None
-    try:
-        with open(config_path, "rb") as f:
-            doc = _toml.load(f)
-    except (OSError, _toml.TOMLDecodeError):
-        # Leave a malformed / unreadable config for the core to report.
-        return None
-
-    entries = (doc.get("dirsql") or {}).get("extension")
-    if not isinstance(entries, list):
-        return None
-    return entries, os.path.dirname(os.path.abspath(config_path))
-
-
-def _has_bare_name(entries):
-    return any(
-        isinstance(e, dict)
-        and isinstance(e.get("path"), str)
-        and is_bare_name(e["path"])
-        for e in entries
-    )
-
-
-def _resolve_entries(entries, base):
-    specs = []
-    for e in entries:
-        entrypoint = e.get("entrypoint")
-        specs.append(
-            {
-                "path": resolve_extension_path(
-                    e["path"], base=base, resolve_relative=True
-                ),
-                "entrypoint": entrypoint if isinstance(entrypoint, str) else None,
-            }
-        )
-    return specs
-
-
-def resolve_config_extension_specs(config_path):
-    """Resolve a TOML config's ``[[dirsql.extension]]`` entries to literal paths.
-
-    Returns a list of ``{"path", "entrypoint"}`` dicts -- every entry resolved
-    via :func:`resolve_extension_path` against the config file's parent
-    directory -- when at least one entry's ``path`` is a bare package name.
-    Returns ``None`` 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. Raises if
-    a package name cannot be resolved.
-    """
-    loaded = _load_extension_entries(config_path)
-    if loaded is None:
-        return None
-    entries, base = loaded
-    if not _has_bare_name(entries):
-        return None
-    return _resolve_entries(entries, base)
-
-
-def resolve_configs_extension_specs(config_paths):
-    """Resolve the ``[[dirsql.extension]]`` entries of several configs, in order.
-
-    The SDK intervenes for the whole set only when **some** config names an
-    extension by bare package name (the core can resolve neither package names
-    nor -- once globally suppressed -- the literal entries of the other
-    configs). When it intervenes it resolves **every** config's entries, each
-    against that config's own parent directory, concatenated in ``config_paths``
-    order; the caller suppresses the core's config-extension loading and passes
-    the resolved list. Returns ``None`` when no config uses a package name,
-    leaving every config's loading to the core.
-    """
-    loaded = [_load_extension_entries(p) for p in config_paths]
-    if not any(item is not None and _has_bare_name(item[0]) for item in loaded):
-        return None
-    specs = []
-    for item in loaded:
-        if item is None:
-            continue
-        entries, base = item
-        specs.extend(_resolve_entries(entries, base))
-    return specs