cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/php/import-decomposer.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Decompose a PHP `namespace_use_declaration` into one or more
+ * `CaptureMatch` objects carrying the synthesized markers
+ * `@import.kind` / `@import.source` / `@import.name` / `@import.alias`
+ * that `interpretPhpImport` consumes.
+ *
+ * PHP import forms handled:
+ *
+ *   use Foo\Bar;                      → namespace, localName=Bar
+ *   use Foo\Bar as Baz;               → alias, localName=Baz
+ *   use function Foo\bar;             → function, localName=bar
+ *   use const Foo\BAR;                → const, localName=BAR
+ *   use Foo\{A, B as C};              → grouped: one match per clause
+ *   use function Foo\{f, g as h};     → grouped function variants
+ *   use const Foo\{X, Y as Z};        → grouped const variants
+ *
+ * Unlike C#'s decomposer this is 1:N — each grouped use_declaration
+ * fans out to one CaptureMatch per inner clause.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitNamespaceUseDeclaration = splitNamespaceUseDeclaration;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Decompose a `namespace_use_declaration` node into one `CaptureMatch`
+ * per logical import. Returns `[]` when the node is unrecognized or
+ * carries no resolvable clauses.
+ */
+function splitNamespaceUseDeclaration(stmtNode) {
+    if (stmtNode.type !== 'namespace_use_declaration')
+        return [];
+    // Detect qualifier keyword: `use function` / `use const`
+    // tree-sitter-php uses a `use_type` or `function`/`const` keyword
+    // child to distinguish them. We scan the raw text before the first
+    // backslash-path child.
+    const qualifier = detectQualifier(stmtNode);
+    // Grouped use: `use Foo\{A, B as C}` — find namespace_use_group child.
+    const groupNode = findNamedChild(stmtNode, 'namespace_use_group');
+    if (groupNode !== null) {
+        return decomposeGrouped(stmtNode, groupNode, qualifier);
+    }
+    // Non-grouped: iterate namespace_use_clause children (one per comma-separated
+    // import in `use A, B, C;`). The first import is also a namespace_use_clause
+    // in the grammar version used by the monorepo; namespace_name child handling
+    // was removed after confirming the clause wrapper covers all positions.
+    const out = [];
+    for (let i = 0; i < stmtNode.namedChildCount; i++) {
+        const child = stmtNode.namedChild(i);
+        if (child === null || child.type !== 'namespace_use_clause')
+            continue;
+        const spec = parseUseClause(child, qualifier);
+        if (spec !== null) {
+            out.push(buildImportMatch(stmtNode, spec));
+        }
+    }
+    return out;
+}
+// ── Qualifier detection ────────────────────────────────────────────────────
+/**
+ * Return the qualifier keyword appearing after `use`:
+ * `'function'`, `'const'`, or `null` for plain namespace use.
+ *
+ * tree-sitter-php emits the qualifier as a `name` node with text
+ * "function" or "const" (not a keyword token in recent grammars),
+ * or as a dedicated `use_type` node. We inspect the node's raw text
+ * to be grammar-version-agnostic.
+ */
+function detectQualifier(node) {
+    const raw = node.text;
+    // Match `use function` or `use const` at the start (after optional whitespace)
+    if (/^\s*use\s+function\s/i.test(raw))
+        return 'function';
+    if (/^\s*use\s+const\s/i.test(raw))
+        return 'const';
+    return 'namespace';
+}
+function parseUseClause(clause, qualifier) {
+    // namespace_use_clause:
+    //   qualified_name (or name)
+    //   optional: alias_clause → "as" name   (some grammar versions)
+    //   optional: bare name node             (tree-sitter-php ≥ 0.22 emits the
+    //                                         alias as a sibling `name` node
+    //                                         directly, not inside alias_clause)
+    const qualName = findNamedChild(clause, 'qualified_name') ?? findNamedChild(clause, 'name');
+    if (qualName === null)
+        return null;
+    const source = qualName.text.trim();
+    if (source === '')
+        return null;
+    // Strategy: bare sibling `name` node after the qualified_name.
+    // tree-sitter-php (≥ 0.22) emits `use Foo\Bar as Baz` as:
+    //   namespace_use_clause
+    //     qualified_name "Foo\Bar"
+    //     name "Baz"          ← alias, no alias_clause wrapper
+    // Detect by: clause has ≥2 named children AND the last named child is
+    // a `name` node that differs from the qualName node.
+    if (clause.namedChildCount >= 2) {
+        const lastChild = clause.namedChild(clause.namedChildCount - 1);
+        if (lastChild !== null && lastChild !== qualName && lastChild.type === 'name') {
+            const alias = lastChild.text.trim();
+            if (alias !== '') {
+                return {
+                    kind: 'alias',
+                    symbolKind: symbolKindFor(qualifier),
+                    source,
+                    name: alias,
+                    alias,
+                    atNode: clause,
+                };
+            }
+        }
+    }
+    return {
+        kind: qualifier,
+        symbolKind: symbolKindFor(qualifier),
+        source,
+        name: lastSegment(source),
+        atNode: clause,
+    };
+}
+// ── Grouped use decomposition ──────────────────────────────────────────────
+/**
+ * Decompose `use Foo\Bar\{A, B as C, function f, const X}` into one
+ * `CaptureMatch` per inner clause.
+ *
+ * The leading prefix (`Foo\Bar`) is prepended to each inner path.
+ * Inner clauses can override the qualifier with their own `function` /
+ * `const` keyword inside the group.
+ */
+function decomposeGrouped(stmtNode, groupNode, outerQualifier) {
+    // The prefix is the namespace_name that precedes the `{...}` group.
+    // tree-sitter-php emits the leading path as a namespace_name child,
+    // not qualified_name.
+    const prefixNode = findNamedChild(stmtNode, 'namespace_name') ?? findNamedChild(stmtNode, 'name');
+    const prefix = prefixNode?.text.trim() ?? '';
+    const out = [];
+    for (let i = 0; i < groupNode.namedChildCount; i++) {
+        const child = groupNode.namedChild(i);
+        if (child === null)
+            continue;
+        // Each child in a group may be:
+        //   namespace_use_clause  — plain or aliased
+        //   namespace_use_type    — `function` or `const` qualifier inside group
+        // We detect an inline qualifier by checking the raw text of the clause.
+        if (child.type !== 'namespace_use_clause')
+            continue;
+        const innerQualifier = detectInnerQualifier(child) ?? outerQualifier;
+        const spec = parseInnerClause(child, prefix, innerQualifier);
+        if (spec !== null) {
+            out.push(buildImportMatch(stmtNode, spec));
+        }
+    }
+    return out;
+}
+/**
+ * Detect an inline qualifier keyword inside a grouped clause.
+ * e.g. `use Foo\{function bar, const BAZ}` — each clause may start with
+ * `function` or `const`.
+ */
+function detectInnerQualifier(clause) {
+    const raw = clause.text.trim();
+    if (/^function\s/i.test(raw))
+        return 'function';
+    if (/^const\s/i.test(raw))
+        return 'const';
+    return null;
+}
+function parseInnerClause(clause, prefix, qualifier) {
+    const qualName = findNamedChild(clause, 'qualified_name') ?? findNamedChild(clause, 'name');
+    if (qualName === null)
+        return null;
+    // Strip inline `function` / `const` text prefix if present in the text.
+    let innerPath = qualName.text.trim();
+    innerPath = innerPath.replace(/^(?:function|const)\s+/i, '').trim();
+    if (innerPath === '')
+        return null;
+    const source = prefix !== '' ? `${prefix}\\${innerPath}` : innerPath;
+    // Strategy: bare sibling `name` node after the qualified_name (tree-sitter-php ≥ 0.22).
+    if (clause.namedChildCount >= 2) {
+        const lastChild = clause.namedChild(clause.namedChildCount - 1);
+        if (lastChild !== null && lastChild !== qualName && lastChild.type === 'name') {
+            const alias = lastChild.text.trim();
+            if (alias !== '') {
+                return {
+                    kind: 'alias',
+                    symbolKind: symbolKindFor(qualifier),
+                    source,
+                    name: alias,
+                    alias,
+                    atNode: clause,
+                };
+            }
+        }
+    }
+    return {
+        kind: qualifier,
+        symbolKind: symbolKindFor(qualifier),
+        source,
+        name: lastSegment(innerPath),
+        atNode: clause,
+    };
+}
+// ── CaptureMatch builder ───────────────────────────────────────────────────
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', stmtNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, spec.kind),
+        '@import.symbol-kind': (0, ast_helpers_js_1.syntheticCapture)('@import.symbol-kind', spec.atNode, spec.symbolKind),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.name),
+    };
+    if (spec.alias !== undefined) {
+        m['@import.alias'] = (0, ast_helpers_js_1.syntheticCapture)('@import.alias', spec.atNode, spec.alias);
+    }
+    return m;
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+/** Last backslash-separated segment: `Foo\Bar\Baz` → `Baz`. */
+function lastSegment(path) {
+    const parts = path.split('\\').filter(Boolean);
+    return parts[parts.length - 1] ?? path;
+}
+function symbolKindFor(kind) {
+    if (kind === 'function')
+        return 'function';
+    if (kind === 'const')
+        return 'const';
+    return 'type';
+}
+/** Find the first named child with a given node type. */
+function findNamedChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null && child.type === type)
+            return child;
+    }
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/php/import-target.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * Adapter from `(ParsedImport, WorkspaceIndex)` → concrete file path.
+ *
+ * Delegates to the existing `resolvePhpImportInternal` (PSR-4 via
+ * composer.json + suffix matching fallback). The `WorkspaceIndex` is
+ * opaque at this layer; consumers wire a `PhpResolveContext` shape
+ * carrying `fromFile` + `allFilePaths`.
+ *
+ * `loadPhpComposerConfig` is the `ScopeResolver.loadResolutionConfig`
+ * implementation — it loads `composer.json` once per workspace pass and
+ * threads the parsed config into every subsequent `resolveImportTarget`
+ * call via the opaque `resolutionConfig` parameter.
+ *
+ * Returning `null` lets the finalize algorithm mark the edge as
+ * `linkStatus: 'unresolved'`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPhpComposerConfig = loadPhpComposerConfig;
+exports.resolvePhpImportTarget = resolvePhpImportTarget;
+exports.resolvePhpImportTargetInternal = resolvePhpImportTargetInternal;
+const php_js_1 = require("../../import-resolvers/php.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function normalizePhpPath(value) {
+    return value.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+}
+function namespaceDirectories(targetRaw, composerConfig, resolved) {
+    const directories = new Set();
+    if (resolved !== null) {
+        const normalizedResolved = normalizePhpPath(resolved);
+        const separator = normalizedResolved.lastIndexOf('/');
+        if (separator >= 0)
+            directories.add(normalizedResolved.slice(0, separator));
+    }
+    if (composerConfig === null)
+        return [...directories];
+    const normalizedTarget = normalizePhpPath(targetRaw);
+    const mappings = [...composerConfig.psr4.entries()].sort((left, right) => {
+        const lengthDifference = right[0].length - left[0].length;
+        return lengthDifference !== 0 ? lengthDifference : left[0].localeCompare(right[0]);
+    });
+    for (const [namespacePrefix, directoryPrefix] of mappings) {
+        const normalizedPrefix = normalizePhpPath(namespacePrefix);
+        if (normalizedTarget !== normalizedPrefix &&
+            !normalizedTarget.startsWith(`${normalizedPrefix}/`)) {
+            continue;
+        }
+        const remainder = normalizedTarget.slice(normalizedPrefix.length).replace(/^\//, '');
+        const separator = remainder.lastIndexOf('/');
+        const relativeNamespace = separator >= 0 ? remainder.slice(0, separator) : '';
+        directories.add(normalizePhpPath(relativeNamespace === '' ? directoryPrefix : `${directoryPrefix}/${relativeNamespace}`));
+        break;
+    }
+    return [...directories];
+}
+// A scope-resolution pass shares one stable parsedFiles array across imports.
+const phpDirectoryIndexCache = new WeakMap();
+function parentDirectory(filePath) {
+    const normalizedPath = normalizePhpPath(filePath);
+    const separator = normalizedPath.lastIndexOf('/');
+    return separator < 0 ? '' : normalizedPath.slice(0, separator);
+}
+function directoryAliases(filePath) {
+    const normalizedPath = normalizePhpPath(filePath);
+    const separator = normalizedPath.lastIndexOf('/');
+    if (separator < 0)
+        return [''];
+    const parent = normalizedPath.slice(0, separator);
+    const aliases = new Set([parent]);
+    const segments = parent.split('/').filter(Boolean);
+    for (let index = 0; index < segments.length; index++) {
+        aliases.add(segments.slice(index).join('/'));
+    }
+    return [...aliases];
+}
+function filesByDirectory(parsedFiles) {
+    const cached = phpDirectoryIndexCache.get(parsedFiles);
+    if (cached)
+        return cached;
+    const mutable = new Map();
+    for (const parsed of parsedFiles) {
+        for (const directory of directoryAliases(parsed.filePath)) {
+            const files = mutable.get(directory) ?? [];
+            files.push(parsed);
+            mutable.set(directory, files);
+        }
+    }
+    phpDirectoryIndexCache.set(parsedFiles, mutable);
+    return mutable;
+}
+// ─── loadResolutionConfig ──────────────────────────────────────────────────
+/**
+ * Load and parse `composer.json` from the repo root. Returns a
+ * `ComposerConfig` object (PSR-4 namespace → directory mappings) or
+ * `null` when no `composer.json` is present or it cannot be parsed.
+ *
+ * The result is threaded into each `resolvePhpImportInternal` call as
+ * the `composerConfig` argument.
+ */
+function loadPhpComposerConfig(repoPath) {
+    try {
+        const composerPath = (0, node_path_1.join)(repoPath, 'composer.json');
+        const raw = (0, node_fs_1.readFileSync)(composerPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const composer = parsed;
+        const autoload = composer['autoload'];
+        if (autoload === undefined)
+            return null;
+        const psr4Raw = (autoload['psr-4'] ?? {});
+        const psr4 = new Map();
+        for (const [ns, dirs] of Object.entries(psr4Raw)) {
+            // namespace prefix ends with `\` — keep as-is; resolver strips it
+            const normalizedNs = ns.replace(/\\$/, '');
+            const dir = Array.isArray(dirs) ? dirs[0] : dirs;
+            if (typeof dir === 'string') {
+                // Normalize directory path (strip trailing slash)
+                const normalizedDir = dir.replace(/\/+$/, '');
+                psr4.set(normalizedNs, normalizedDir);
+            }
+        }
+        return { psr4 };
+    }
+    catch {
+        return null;
+    }
+}
+// ─── resolvePhpImportTarget ────────────────────────────────────────────────
+/**
+ * LanguageProvider-shaped adapter: `(ParsedImport, WorkspaceIndex) → string | null`.
+ *
+ * The `WorkspaceIndex` is `unknown` in the shared contract. The scope-resolution
+ * orchestrator hands us a `PhpResolveContext`-shaped object; narrow structurally
+ * rather than via a cast chain so unexpected shapes return `null` cleanly.
+ */
+function resolvePhpImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        !(ctx.allFilePaths instanceof Set)) {
+        return null;
+    }
+    if (parsedImport.kind === 'dynamic-unresolved')
+        return null;
+    if (parsedImport.targetRaw === null || parsedImport.targetRaw === '')
+        return null;
+    const allFiles = ctx.allFilePaths;
+    const normalizedFileList = [...allFiles].map((f) => f.replace(/\\/g, '/'));
+    const allFileList = [...allFiles];
+    return (0, php_js_1.resolvePhpImportInternal)(parsedImport.targetRaw, null, // composerConfig not available through LanguageProvider path
+    allFiles, normalizedFileList, allFileList, undefined);
+}
+/**
+ * ScopeResolver-shaped adapter: `(targetRaw, fromFile, allFilePaths, resolutionConfig?) → string | null`.
+ *
+ * Used inside `scope-resolver.ts`. Accepts the optional `resolutionConfig`
+ * (a `ComposerConfig | null` loaded once per workspace by
+ * `loadPhpComposerConfig`) and threads it into `resolvePhpImportInternal`.
+ */
+function resolvePhpImportTargetInternal(targetRaw, _fromFile, allFilePaths, resolutionConfig, context) {
+    if (targetRaw === '')
+        return null;
+    const composerConfig = resolutionConfig !== undefined && resolutionConfig !== null
+        ? resolutionConfig
+        : null;
+    const allFiles = allFilePaths;
+    const normalizedFileList = [...allFiles].map((f) => f.replace(/\\/g, '/'));
+    const allFileList = [...allFiles];
+    const resolved = (0, php_js_1.resolvePhpImportInternal)(targetRaw, composerConfig, allFiles, normalizedFileList, allFileList, undefined);
+    const parsedImport = context?.parsedImport;
+    const symbolKind = parsedImport?.kind === 'named' || parsedImport?.kind === 'alias'
+        ? parsedImport.importedSymbolKind
+        : undefined;
+    if (context === undefined ||
+        parsedImport === undefined ||
+        (symbolKind !== 'function' && symbolKind !== 'const')) {
+        return resolved;
+    }
+    const importedName = targetRaw.replace(/\\/g, '/').split('/').filter(Boolean).at(-1);
+    if (importedName === undefined)
+        return resolved;
+    const directories = namespaceDirectories(targetRaw, composerConfig, resolved);
+    const directoryIndex = filesByDirectory(context.parsedFiles);
+    const candidateFiles = [
+        ...new Set(directories.flatMap((directory) => {
+            const files = directoryIndex.get(normalizePhpPath(directory)) ?? [];
+            // A suffix alias can match directories under different roots (for
+            // example app/Models and vendor/pkg/app/Models). Picking either root
+            // would be a guess, so fail closed to the composer resolution instead.
+            const distinctParents = new Set(files.map((file) => parentDirectory(file.filePath)));
+            return distinctParents.size > 1 ? [] : files;
+        })),
+    ];
+    const expectedType = symbolKind === 'function' ? 'Function' : 'Variable';
+    const declaringFiles = candidateFiles.filter((parsed) => parsed.localDefs.some((def) => {
+        if (def.type !== expectedType)
+            return false;
+        const simpleName = (def.qualifiedName ?? '').split(/[\\.]/).at(-1);
+        return simpleName === importedName;
+    }));
+    if (declaringFiles.length > 1)
+        return null;
+    if (declaringFiles.length === 1)
+        return declaringFiles[0].filePath;
+    // PHP constants are not currently emitted as local definitions. A single
+    // file in the namespace directory is still unambiguous; multiple files must
+    // fail closed rather than inheriting Set iteration order.
+    if (symbolKind === 'const' && candidateFiles.length === 1)
+        return candidateFiles[0].filePath;
+    return resolved;
+}

package/dist/core/code/engine/core/ingestion/languages/php/index.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * PHP scope-resolution hooks (RFC #909 Ring 3 LANG-php, #938).
+ *
+ * Public API barrel. Consumers should import from this file rather than
+ * the individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`               — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`            — `emitPhpScopeCaptures` orchestrator
+ *   - `import-decomposer.ts`   — each `namespace_use_declaration` → ParsedImport captures
+ *   - `interpret.ts`           — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`        — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`    — synthesize `$this` / `parent` type-bindings on
+ *                                instance-method entry
+ *   - `merge-bindings.ts`      — PHP `use` precedence (local > import > wildcard)
+ *   - `arity.ts`               — PHP arity compatibility (variadic, defaults)
+ *   - `arity-metadata.ts`      — synthesize arity metadata from declarations
+ *   - `import-target.ts`       — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *                                wrapping `resolvePhpImportInternal` (PSR-4 + composer.json)
+ *   - `scope-resolver.ts`      — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`         — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ *
+ * ## Known limitations
+ *
+ * The PHP registry-primary path intentionally does NOT resolve the following.
+ * Each is a conscious trade-off at migration time.
+ *
+ *   1. **Trait `$this` → using-class binding** — for methods defined in a
+ *      trait, `$this` is synthesized as a binding to the trait itself.
+ *      Resolving `$this` to the actual using-class type requires cross-file
+ *      analysis of all `use TraitName;` declarations in class bodies.
+ *      Deferred to a follow-up; trait method resolution falls back to the
+ *      trait scope.
+ *
+ *   2. **Anonymous classes** — `new class extends Foo { }` have no stable
+ *      class name and are skipped by receiver-binding synthesis. The class
+ *      body is still scoped; member lookups inside it will fall back to
+ *      free-call resolution.
+ *
+ *   3. **Dynamic property/method access** — `$obj->{$name}()` and
+ *      `$$varName` are not followed. The dynamic receiver is ignored and
+ *      the call falls through to the shared free-call resolver.
+ *
+ *   4. **Magic methods** — `__get`, `__set`, `__call`, `__callStatic` are
+ *      not modeled as virtual dispatch; they appear as regular method
+ *      declarations in the graph but calls that would route through them
+ *      at runtime are not distinguished.
+ *
+ *   5. **Laravel facade magic** — `App::make(...)`, `Cache::get(...)` etc.
+ *      resolve statically to the Facade class rather than the underlying
+ *      bound implementation. Deferred to a Laravel-specific plugin.
+ *
+ *   6. **Intersection types in parameters** — `T&U $param` takes the first
+ *      named part (`T`). This matches the legacy type-extractor's behavior.
+ *
+ * The `test/integration/resolvers/php.test.ts` resolver suite is the
+ * authoritative signal for which of these matter in practice; it runs in
+ * the standard CI test workflow, so a regression blocks the merge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.phpReceiverBinding = exports.phpImportOwningScope = exports.phpBindingScopeFor = exports.resolvePhpImportTarget = exports.phpArityCompatibility = exports.phpMergeBindings = exports.interpretPhpTypeBinding = exports.interpretPhpImport = exports.resetPhpCaptureCacheStats = exports.getPhpCaptureCacheStats = exports.emitPhpScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitPhpScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitPhpScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getPhpCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getPhpCaptureCacheStats; } });
+Object.defineProperty(exports, "resetPhpCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetPhpCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretPhpImport", { enumerable: true, get: function () { return interpret_js_1.interpretPhpImport; } });
+Object.defineProperty(exports, "interpretPhpTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretPhpTypeBinding; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "phpMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.phpMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "phpArityCompatibility", { enumerable: true, get: function () { return arity_js_1.phpArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolvePhpImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolvePhpImportTarget; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "phpBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.phpBindingScopeFor; } });
+Object.defineProperty(exports, "phpImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.phpImportOwningScope; } });
+Object.defineProperty(exports, "phpReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.phpReceiverBinding; } });
+// NOTE: phpScopeResolver is intentionally NOT re-exported from this barrel.
+// Importing it here would create a circular dependency:
+//   php.ts → php/index.js → php/scope-resolver.js → ../php.js
+// Registry and other consumers must import directly from './php/scope-resolver.js'.