@geastack/compiler 1.0.15

package/dist/targets/cpp/virtual-methods.d.ts

@@ -0,0 +1,95 @@
+import type { DeclarationId, FunctionId } from '../../identity/ids.js';
+import type { CallableAbi } from '../../representation/model.js';
+import type { ClassLayout } from '../../projection/classes.js';
+import { extendsClass, virtualDispatchKey, virtualMethodFamiliesOf, type VirtualDispatchVerdict, type VirtualFamilyRefusal, type VirtualFamilyVerdict, type VirtualMemberRole, type VirtualMethodFamily, type VirtualMethodImplementor } from '../../projection/dispatch.js';
+export { extendsClass, virtualDispatchKey, virtualMethodFamiliesOf, type VirtualDispatchVerdict, type VirtualFamilyRefusal, type VirtualFamilyVerdict, type VirtualMemberRole, type VirtualMethodFamily, type VirtualMethodImplementor };
+import { type ConversionSite } from './emit-narrowing.js';
+/**
+ * Dispatch for a method the program overrides.
+ *
+ * `class-layout.ts` resolves a member by walking UP from the receiver's class,
+ * which is the language's lookup only when the receiver's class is known
+ * exactly. It is not what a CALL does: a receiver annotated as a base holds
+ * whatever was constructed, and the language runs that object's implementation.
+ * Binding the body the upward walk found is therefore right only while nothing
+ * below redeclares the key -- and when something does, the emitted program runs
+ * the base's body for every instance of a subclass, compiles, links, and is
+ * silently wrong. gea3d-cube is the worked case: `Object3D.collectSelf` is
+ * empty and `Mesh`/`Light` override it, so the renderer's scene walk collected
+ * zero meshes and painted a cleared frame with no diagnostic anywhere.
+ *
+ * The mechanism here is C++'s own. The emitted structs already model the
+ * language's inheritance as C++ inheritance (`records.ts`), single and with the
+ * base subobject at offset zero -- which `gea::Ref`'s converting constructor
+ * asserts -- so a virtual member on the root struct dispatches exactly as the
+ * language specifies, at the cost of one vtable pointer per object. Nothing
+ * else in the emission has to change shape: the member forwards to the same
+ * free-function body the direct bind used to name.
+ */
+export interface VirtualMethodRefusal {
+    readonly key: string;
+    readonly owner: DeclarationId;
+    readonly reason: string;
+}
+/**
+ * The C++ member one family dispatches through.
+ *
+ * Prefixed rather than named after the key alone: a class may declare a FIELD
+ * and a method whose names would otherwise collide inside one struct, and the
+ * field's spelling is already `cppRecordFieldName`'s.
+ */
+export declare const cppVirtualMemberName: (key: string, role?: VirtualMemberRole) => string;
+export interface VirtualMethodEmission {
+    /** Member declarations to place inside each struct, by struct name. */
+    readonly membersByStruct: ReadonlyMap<string, readonly string[]>;
+    /** Out-of-line definitions, emitted after every body has been declared. */
+    readonly definitions: readonly string[];
+    /** Families that cannot be dispatched, so the call sites refuse rather than bind one body. */
+    readonly refused: readonly VirtualMethodRefusal[];
+    /** Every `class key` a call site may dispatch, with the root member ABI it must call. */
+    readonly dispatched: ReadonlyMap<string, CallableAbi>;
+}
+/**
+ * The struct members and out-of-line definitions for every family
+ * `verdict` already proved dispatchable.
+ *
+ * This function used to decide dispatchability itself (an ABI-compatibility
+ * walk plus a capture-environment refusal, both duplicated between here and
+ * whatever asked the same question before a call site was allowed to bind a
+ * body directly). That verdict is `projection/dispatch.ts`'s
+ * `virtualDispatchVerdictOf` now, computed once by `translation-unit.ts` from
+ * the published `IrBody.facts` and threaded in as `verdict` -- this file
+ * reads the fact and renders it, rather than re-deriving it from a whole-unit
+ * capture index at render time the way `targets/cpp/captures.ts`'s
+ * `buildCaptureIndex` used to require.
+ */
+export declare const virtualMethodEmission: (site: ConversionSite, classes: ReadonlyMap<DeclarationId, ClassLayout>, abiOf: (callable: FunctionId) => CallableAbi | null, verdict: VirtualDispatchVerdict) => VirtualMethodEmission;
+export interface PrototypeReadHooks {
+    readonly membersByStruct: ReadonlyMap<string, readonly string[]>;
+    readonly definitions: readonly string[];
+}
+/**
+ * The runtime's `NativePrototypeTable` hooks for every class that declares a
+ * getter or method, so a boxed instance answers a dynamic read of either.
+ *
+ * A class accessor has no storage (`ClassLayout.accessors`), so the boxed
+ * payload's field table cannot see it, and `Value::getProperty` found nothing
+ * and answered `undefined` -- `@hono/node-server` reads `request.method` off
+ * an `Object.create`d instance it only holds as `any`. The hook calls the
+ * getter's own body on the instance and boxes its result; a getter whose
+ * result has no boxed form is left out rather than answered wrongly.
+ *
+ * The nearest ancestor with getters declares the members `virtual`, so the
+ * runtime's `static_cast` to the box's declared class still reaches the
+ * dynamic class's getters; a class without getters of its own inherits them.
+ *
+ * `readDynamically` is the reflection census's verdict per class (the same
+ * `full`-demand answer `records.ts` spells the struct's own dynamic field
+ * protocol from, bases included): only a class some box can hold is ever
+ * asked for a prototype property through `gea::Value`, and a class no box
+ * holds gets no hook -- the hook's method arm boxes every method into a
+ * `gea::Value` function object, which a program whose classes never reach a
+ * dynamic carrier must not spell at all (`test/stored-listener-native-flow`,
+ * `native-method-overrides`' `emitted-lacks: gea::Value::box`).
+ */
+export declare const prototypeReadHooks: (classes: ReadonlyMap<DeclarationId, ClassLayout>, abiOf: (callable: FunctionId) => CallableAbi | null, capturesNothing: (callable: FunctionId) => boolean, readDynamically: (declaration: DeclarationId) => boolean) => PrototypeReadHooks;

package/dist/targets/cpp/virtual-methods.js

@@ -0,0 +1,264 @@
+import { extendsClass, virtualDispatchKey, virtualMethodFamiliesOf } from '../../projection/dispatch.js';
+export { extendsClass, virtualDispatchKey, virtualMethodFamiliesOf };
+import { cppFormalName } from './emit-context.js';
+import { cppAbiParameterType, cppBodyName, cppClassName, cppRecordFieldName, cppResultTypeOf, cppStringLiteral, cppTypeOf, cppUndefinedIn } from './types.js';
+import { alignedValueText, dynamicCarrierBoxText } from './emit-narrowing.js';
+/**
+ * The C++ member one family dispatches through.
+ *
+ * Prefixed rather than named after the key alone: a class may declare a FIELD
+ * and a method whose names would otherwise collide inside one struct, and the
+ * field's spelling is already `cppRecordFieldName`'s.
+ */
+export const cppVirtualMemberName = (key, role = 'call') => `${role === 'set' ? 'gea_vset_' : role === 'get' ? 'gea_vget_' : 'gea_vcall_'}${cppRecordFieldName(key)}`;
+/** The parameter list a family's member takes: the body's ABI minus the receiver, which becomes `this`. */
+const memberFormalsOf = (abi) => abi.parameters.map((parameter, ordinal) => `${cppAbiParameterType(parameter)} ${cppFormalName(ordinal)}`);
+/**
+ * The receiver/parameter/result conversion TEXT for a class-ref pair.
+ *
+ * `projection/dispatch.ts`'s `virtualDispatchVerdictOf` already proved this
+ * pair is one of the two shapes below (same-or-ancestor, or a runtime-checked
+ * descendant) before this file is ever asked to spell it -- see that module's
+ * `classRefConvertible`, the identical structural test with no text attached.
+ * A `null` return here on a pair the verdict approved is therefore this
+ * file's own bug, not a program defect, and `virtualMethodAdapterOf` treats it
+ * as exactly that (a thrown internal error, never a refusal).
+ */
+const classRefConversionText = (classes, source, target, text) => {
+    if (source.ownership !== 'shared-refcount' || target.ownership !== 'shared-refcount')
+        return null;
+    if (source.declaration === target.declaration || extendsClass(classes, source.declaration, target.declaration)) {
+        return `${cppTypeOf(target)}(${text})`;
+    }
+    if (!extendsClass(classes, target.declaration, source.declaration))
+        return null;
+    const possible = [...classes.keys()]
+        .filter((declaration) => declaration === target.declaration || extendsClass(classes, declaration, target.declaration))
+        .sort((left, right) => String(left).localeCompare(String(right)));
+    if (possible.length === 0)
+        return null;
+    const test = `gea::host::hasNativeClassLayoutRef<${possible.map(cppClassName).join(', ')}>(${text})`;
+    const failure = `std::fprintf(stderr, "gea: virtual dispatch argument is not an instance of ${String(target.declaration)}\\n"); ` + 'std::abort();';
+    return `[&]() -> ${cppTypeOf(target)} { if (!${test}) { ${failure} } return gea::host::downcastClassRef<${cppClassName(target.declaration)}>(${text}); }()`;
+};
+const virtualValueConversionText = (site, classes, source, target, text) => {
+    if (source.kind === 'class-ref' && target.kind === 'class-ref')
+        return classRefConversionText(classes, source, target, text);
+    return alignedValueText(site, 'virtual-methods.ts:189', source, target, text);
+};
+/**
+ * One implementor's out-of-line body, as an expression the family's member
+ * forwards to.
+ *
+ * Every conversion here was already PROVED to exist by `virtualDispatchVerdictOf`
+ * -- this function only has to spell it. A `null`/`undefined` from a text
+ * builder that the verdict already cleared is therefore an internal
+ * consistency error (this file drifting from `projection/dispatch.ts`'s own
+ * predicate), reported as a thrown `Error` rather than folded into
+ * `VirtualMethodEmission.refused`: refusing here would silently drop a
+ * program the verdict certified as dispatchable, which is worse than crashing
+ * loudly on a compiler bug.
+ */
+const virtualMethodAdapterOf = (site, classes, family, implementor, rootAbi, actualAbi) => {
+    // Every `?? drift(...)` below leans on `drift`'s `never` return type to
+    // both throw AND narrow the left-hand side to its non-null variant, rather
+    // than on an `if`-then-throw's control-flow narrowing -- the same value,
+    // asked the more robust of the two ways this file's own architecture
+    // rules already prefer over a non-null assertion.
+    const drift = (what) => throwVirtualAdapterDrift(family, implementor, `the dispatch verdict proved ${what} converts, but this file could not spell it`);
+    const receiverAbi = actualAbi.receiver ?? drift('a receiver');
+    const instanceValue = classes.get(implementor.declaration)?.instance ?? null;
+    const instance = instanceValue !== null && instanceValue.kind === 'class-ref' ? instanceValue : drift('a class-ref instance carrier');
+    const receiverText = virtualValueConversionText(site, classes, instance, receiverAbi, `gea::Ref<${cppClassName(implementor.declaration)}>::adopt(this, true)`) ?? drift('a receiver');
+    const actuals = [receiverText];
+    for (const [position, parameter] of actualAbi.parameters.entries()) {
+        const source = rootAbi.parameters[position];
+        if (source !== undefined) {
+            actuals.push(virtualValueConversionText(site, classes, source.value, parameter.value, cppFormalName(position)) ?? drift(`parameter ${position}`));
+            continue;
+        }
+        if (actualAbi.restFrom === position && parameter.value.kind === 'array-object') {
+            actuals.push(`gea::makeRef<gea::ArrayObject<${cppTypeOf(parameter.value.element)}>>()`);
+            continue;
+        }
+        actuals.push(cppUndefinedIn(parameter.value) ?? drift(`an undefined default for parameter ${position}`));
+    }
+    const invocation = `${cppBodyName(implementor.callable)}(${actuals.join(', ')})`;
+    const result = virtualValueConversionText(site, classes, actualAbi.result, rootAbi.result, invocation) ?? drift('the result');
+    return { result };
+};
+const throwVirtualAdapterDrift = (family, implementor, reason) => {
+    throw new Error(`virtual method adapter for ${implementor.declaration}.${family.key}: ${reason}`);
+};
+/**
+ * The struct members and out-of-line definitions for every family
+ * `verdict` already proved dispatchable.
+ *
+ * This function used to decide dispatchability itself (an ABI-compatibility
+ * walk plus a capture-environment refusal, both duplicated between here and
+ * whatever asked the same question before a call site was allowed to bind a
+ * body directly). That verdict is `projection/dispatch.ts`'s
+ * `virtualDispatchVerdictOf` now, computed once by `translation-unit.ts` from
+ * the published `IrBody.facts` and threaded in as `verdict` -- this file
+ * reads the fact and renders it, rather than re-deriving it from a whole-unit
+ * capture index at render time the way `targets/cpp/captures.ts`'s
+ * `buildCaptureIndex` used to require.
+ */
+export const virtualMethodEmission = (site, classes, abiOf, verdict) => {
+    const membersByStruct = new Map();
+    const definitions = [];
+    for (const { family, rootAbi } of verdict.families) {
+        const adapters = new Map();
+        for (const implementor of family.implementors) {
+            const actualAbi = abiOf(implementor.callable) ??
+                throwVirtualAdapterDrift(family, implementor, 'the dispatch verdict proved a callable convention exists, but this file found none');
+            adapters.set(implementor.declaration, virtualMethodAdapterOf(site, classes, family, implementor, rootAbi, actualAbi));
+        }
+        const formals = memberFormalsOf(rootAbi).join(', ');
+        const result = cppResultTypeOf(rootAbi.result);
+        if (family.abstractRoot) {
+            // Declared on the root and DEFINED, rather than pure virtual: nothing in
+            // the program can construct an abstract class, but `gea::Ref`'s
+            // operations table and every downcast name the root type, and an
+            // abstract C++ type is a different type for all of them. TypeScript
+            // already proves every concrete subclass overrides this, so the
+            // definition is unreachable and says so instead of returning a value it
+            // would have to invent.
+            const failure = `std::fprintf(stderr, "gea: abstract method ${String(family.root)}.${family.key} has no implementation\\n"); std::abort();`;
+            membersByStruct.set(cppClassName(family.root), [
+                ...(membersByStruct.get(cppClassName(family.root)) ?? []),
+                `  virtual ${result} ${cppVirtualMemberName(family.key, family.role)}(${formals});`
+            ]);
+            definitions.push(`${result} ${cppClassName(family.root)}::${cppVirtualMemberName(family.key, family.role)}(${formals}) { ${failure} }`);
+        }
+        for (const implementor of family.implementors) {
+            const structName = cppClassName(implementor.declaration);
+            const isRoot = implementor.declaration === family.root && !family.abstractRoot;
+            const members = membersByStruct.get(structName) ?? [];
+            members.push(`  ${isRoot ? 'virtual ' : ''}${result} ${cppVirtualMemberName(family.key, family.role)}(${formals})${isRoot ? '' : ' override'};`);
+            membersByStruct.set(structName, members);
+            const adapter = adapters.get(implementor.declaration);
+            if (adapter === undefined)
+                throw new Error(`virtual method adapter for ${implementor.declaration}.${family.key} was not retained`);
+            definitions.push(`${result} ${structName}::${cppVirtualMemberName(family.key, family.role)}(${formals}) { ${result === 'void' ? '' : 'return '}${adapter.result}; }`);
+        }
+    }
+    return {
+        membersByStruct,
+        definitions,
+        refused: verdict.refused.map((refusal) => ({ key: refusal.key, owner: refusal.owner, reason: refusal.reason })),
+        dispatched: new Map([...verdict.dispatched].map(([key, entry]) => [key, entry.rootAbi]))
+    };
+};
+/**
+ * The runtime's `NativePrototypeTable` hooks for every class that declares a
+ * getter or method, so a boxed instance answers a dynamic read of either.
+ *
+ * A class accessor has no storage (`ClassLayout.accessors`), so the boxed
+ * payload's field table cannot see it, and `Value::getProperty` found nothing
+ * and answered `undefined` -- `@hono/node-server` reads `request.method` off
+ * an `Object.create`d instance it only holds as `any`. The hook calls the
+ * getter's own body on the instance and boxes its result; a getter whose
+ * result has no boxed form is left out rather than answered wrongly.
+ *
+ * The nearest ancestor with getters declares the members `virtual`, so the
+ * runtime's `static_cast` to the box's declared class still reaches the
+ * dynamic class's getters; a class without getters of its own inherits them.
+ *
+ * `readDynamically` is the reflection census's verdict per class (the same
+ * `full`-demand answer `records.ts` spells the struct's own dynamic field
+ * protocol from, bases included): only a class some box can hold is ever
+ * asked for a prototype property through `gea::Value`, and a class no box
+ * holds gets no hook -- the hook's method arm boxes every method into a
+ * `gea::Value` function object, which a program whose classes never reach a
+ * dynamic carrier must not spell at all (`test/stored-listener-native-flow`,
+ * `native-method-overrides`' `emitted-lacks: gea::Value::box`).
+ */
+export const prototypeReadHooks = (classes, abiOf, capturesNothing, readDynamically) => {
+    // A method read yields a fresh function object over the body: a dynamic
+    // read is followed by a call, and nothing on that path compares identities.
+    const methods = (layout) => layout.methods.flatMap((method) => {
+        if (method.callable === null || !capturesNothing(method.callable))
+            return [];
+        const abi = abiOf(method.callable);
+        if (abi === null || abi.receiver === null)
+            return [];
+        const value = { kind: 'function-value-dispatch', abi };
+        const receiver = abi.receiver;
+        const formals = [
+            `${cppTypeOf(receiver)} gea_receiver`,
+            ...abi.parameters.map((p, i) => `${cppAbiParameterType(p)} ${cppFormalName(i)}`)
+        ];
+        const actuals = ['gea_receiver', ...abi.parameters.map((_, i) => cppFormalName(i))];
+        const thunk = `+[](void*, ${formals.join(', ')}) -> ${cppResultTypeOf(abi.result)} { return ${cppBodyName(method.callable)}(${actuals.join(', ')}); }`;
+        const boxed = dynamicCarrierBoxText(value, `${cppTypeOf(value)}{${thunk}, nullptr}`);
+        return boxed === null ? [] : [{ key: method.key, text: boxed }];
+    });
+    const readable = (layout) => [
+        ...layout.accessors.flatMap((accessor) => {
+            if (accessor.getter === null || !capturesNothing(accessor.getter))
+                return [];
+            const abi = abiOf(accessor.getter);
+            if (abi === null || abi.receiver === null || abi.parameters.length > 0 || abi.restFrom !== null)
+                return [];
+            if (layout.instance?.kind !== 'class-ref' || abi.receiver.kind !== 'class-ref')
+                return [];
+            const self = `gea::Ref<${cppClassName(layout.declaration)}>::adopt(const_cast<${cppClassName(layout.declaration)}*>(this), true)`;
+            const receiver = classRefConversionText(classes, layout.instance, abi.receiver, self);
+            if (receiver === null)
+                return [];
+            const invocation = `${cppBodyName(accessor.getter)}(${receiver})`;
+            if (abi.result.kind === 'undefined' || cppResultTypeOf(abi.result) === 'void')
+                return [];
+            const boxed = abi.result.kind === 'dynamic' ? invocation : dynamicCarrierBoxText(abi.result, invocation);
+            return boxed === null ? [] : [{ key: accessor.key, text: boxed }];
+        }),
+        ...methods(layout)
+    ];
+    const own = new Map();
+    for (const [declaration, layout] of classes) {
+        if (!readDynamically(declaration))
+            continue;
+        const getters = readable(layout);
+        if (getters.length > 0)
+            own.set(declaration, getters);
+    }
+    const hookedAncestorOf = (declaration) => {
+        for (let base = classes.get(declaration)?.base ?? null; base !== null; base = classes.get(base)?.base ?? null)
+            if (own.has(base))
+                return base;
+        return null;
+    };
+    const membersByStruct = new Map();
+    const definitions = [];
+    for (const [declaration, getters] of own) {
+        const struct = cppClassName(declaration);
+        const ancestor = hookedAncestorOf(declaration);
+        const [lead, tail] = ancestor === null ? ['virtual ', ''] : ['', ' override'];
+        membersByStruct.set(struct, [
+            `  ${lead}bool gea_readPrototypeProperty(const gea::PropertyKey& gea_key, gea::Value& gea_out) const${tail};`,
+            `  ${lead}bool gea_hasPrototypeProperty(const gea::PropertyKey& gea_key) const${tail};`,
+            `  ${lead}gea::detail::NativePrototypeOps::SetResult gea_setPrototypeProperty(const gea::PropertyKey& gea_key, const gea::Value& gea_value, const gea::Value& gea_receiver)${tail};`
+        ]);
+        const inherited = ancestor === null ? null : cppClassName(ancestor);
+        const names = getters.map((getter) => cppStringLiteral(getter.key));
+        definitions.push([
+            `bool ${struct}::gea_readPrototypeProperty(const gea::PropertyKey& gea_key, gea::Value& gea_out) const {`,
+            '  if (!gea_key.isSymbol()) {',
+            '    const std::string& gea_name = gea_key.text();',
+            ...getters.map((getter, index) => `    if (gea_name == ${names[index]}) { gea_out = ${getter.text}; return true; }`),
+            '  }',
+            `  return ${inherited === null ? 'false' : `${inherited}::gea_readPrototypeProperty(gea_key, gea_out)`};`,
+            '}',
+            `bool ${struct}::gea_hasPrototypeProperty(const gea::PropertyKey& gea_key) const {`,
+            `  if (!gea_key.isSymbol() && (${names.map((name) => `gea_key.text() == ${name}`).join(' || ')})) return true;`,
+            `  return ${inherited === null ? 'false' : `${inherited}::gea_hasPrototypeProperty(gea_key)`};`,
+            '}',
+            // Setters stay on the static paths; a dynamic write falls through to the payload's own fields.
+            `gea::detail::NativePrototypeOps::SetResult ${struct}::gea_setPrototypeProperty(const gea::PropertyKey&, const gea::Value&, const gea::Value&) {`,
+            '  return gea::detail::NativePrototypeOps::SetResult::Absent;',
+            '}'
+        ].join('\n'));
+    }
+    return { membersByStruct, definitions };
+};

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@geastack/compiler",
+  "version": "1.0.15",
+  "description": "The geastack TypeScript-to-C++ compiler: one semantic spine, no source-shaped authority, no boxing of statically typed values.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geastack/compiler.git"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "type": "module",
+  "bin": {
+    "geatsc": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/compiler.d.ts",
+      "import": "./dist/compiler.js"
+    },
+    "./package.json": "./package.json",
+    "./plugin": {
+      "types": "./dist/plugins/model.d.ts",
+      "import": "./dist/plugins/model.js"
+    },
+    "./preparation": {
+      "types": "./dist/project-preparation.d.ts",
+      "import": "./dist/project-preparation.js"
+    },
+    "./dist/*": "./dist/*",
+    "./src/*": "./src/*"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "src/targets/cpp/runtime/*.h",
+    "src/targets/cpp/runtime/gea_runtime_builtins.cpp",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "test:cli-plugins": "node --test test/cli-plugins.mjs",
+    "test:allocation-runtime": "node test/allocation-runtime.mjs",
+    "test:stored-listener-native-flow": "node test/stored-listener-native-flow.mjs",
+    "test:native-typed-field-read": "node test/native-typed-field-read.mjs",
+    "test:native-method-overrides": "node test/native-method-overrides.mjs",
+    "architecture": "node scripts/architecture.mjs && node scripts/refusal-keys.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:commonjs": "node --test test/commonjs-module-record.mjs",
+    "test:global-host-mutations": "node --test dist/semantics/global-this-host-bindings.test.js && node --test dist/semantics/normalize/deferred-intrinsic-protocols.test.js",
+    "test:binding-composition": "node --test dist/semantics/normalize/binding-composition.test.js",
+    "test:dynamic-value-metadata": "node test/dynamic-value-metadata.mjs",
+    "test:native-field-descriptors": "node test/native-field-descriptors.mjs",
+    "test:declaration-overlays": "node --test dist/semantics/declaration-overlay-transform.test.js",
+    "test:recursive-native-carriers": "node test/recursive-native-carriers.mjs",
+    "test:hot-path-shapes": "node test/hot-path-shapes.mjs",
+    "build": "npm run architecture && tsc -p tsconfig.json && node scripts/mark-bins-executable.mjs && npm run test:binding-composition && npm run test:global-host-mutations && node scripts/check-runtime-header.mjs && npm run test:recursive-native-carriers && npm run test:dynamic-value-metadata && node test/compiler-value-contracts.mjs && npm run test:declaration-overlays && npm run test:hot-path-shapes",
+    "gate": "node scripts/emitted-gate.mjs",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check": "npm run architecture && npm run typecheck && npm run format:check",
+    "check:contracts": "npm run build && node test/contracts.mjs"
+  },
+  "dependencies": {
+    "@geastack/node-compat": "^1.0.7",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "fastify": "^5.0.0",
+    "find-my-way": "9.6.0",
+    "prettier": "^3.8.3"
+  },
+  "peerDependencies": {
+    "@geastack/apple": ">=0.1.0",
+    "@geastack/geatsc-plugin-apple-native": ">=0.1.0",
+    "@geastack/geatsc-plugin-gea": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@geastack/apple": {
+      "optional": true
+    },
+    "@geastack/geatsc-plugin-apple-native": {
+      "optional": true
+    },
+    "@geastack/geatsc-plugin-gea": {
+      "optional": true
+    }
+  }
+}