@aws-blocks/core 0.3.0 → 0.5.0

package/dist/scripts/extract-ts-types.test.js

@@ -25,6 +25,45 @@ const API_NS_MOCK = `
 	interface ApiNamespaceConstructor { new <T>(scope: any, name: string, handler: (ctx: any) => T): T; }
 	const ApiNamespace: ApiNamespaceConstructor = class {} as any;
 `;
+describe('extractMethodTypes — namespaces sharing a method name (regression: #445)', () => {
+    it('keys methods by namespace, so a shared method name does not cross-assign schemas', () => {
+        const dir = createTempProject({
+            'tsconfig.json': JSON.stringify({
+                compilerOptions: { target: 'ESNext', module: 'ESNext', moduleResolution: 'bundler', strict: true },
+            }),
+            'index.ts': `
+				${API_NS_MOCK}
+
+				// Two namespaces both expose \`create\`, with deliberately incompatible contracts.
+				export const widgets = new ApiNamespace(null, 'widgets', (context) => ({
+					async create(label: string): Promise<{ widgetId: string }> {
+						return { widgetId: 'w' };
+					},
+				}));
+				export const subscriptions = new ApiNamespace(null, 'subscriptions', (context) => ({
+					async create(topicCount: number): Promise<{ subId: number }> {
+						return { subId: 1 };
+					},
+				}));
+			`,
+        });
+        try {
+            const types = extractMethodTypes(join(dir, 'index.ts'));
+            // Distinct qualified keys — no collision.
+            assert.ok(types.has('widgets.create'), 'widgets.create should be keyed by namespace');
+            assert.ok(types.has('subscriptions.create'), 'subscriptions.create should be keyed by namespace');
+            assert.ok(!types.has('create'), 'no bare-name entry that could cross-assign');
+            // Each keeps its OWN parameter type.
+            assert.strictEqual(types.get('widgets.create').params[0].name, 'label');
+            assert.strictEqual(types.get('widgets.create').params[0].schema.type, 'string');
+            assert.strictEqual(types.get('subscriptions.create').params[0].name, 'topicCount');
+            assert.strictEqual(types.get('subscriptions.create').params[0].schema.type, 'number');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
 describe('extractMethodTypes — direct ApiNamespace calls', () => {
     it('extracts param and return types from inline ApiNamespace', () => {
         const dir = createTempProject({
@@ -53,13 +92,13 @@ describe('extractMethodTypes — direct ApiNamespace calls', () => {
         });
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
-            assert.ok(types.has('getUser'), 'should find getUser');
-            assert.ok(types.has('createUser'), 'should find createUser');
-            const getUser = types.get('getUser');
+            assert.ok(types.has('api.getUser'), 'should find getUser');
+            assert.ok(types.has('api.createUser'), 'should find createUser');
+            const getUser = types.get('api.getUser');
             assert.strictEqual(getUser.params.length, 1);
             assert.strictEqual(getUser.params[0].name, 'id');
             assert.strictEqual(getUser.params[0].schema.type, 'string');
-            const createUser = types.get('createUser');
+            const createUser = types.get('api.createUser');
             assert.strictEqual(createUser.params.length, 2);
             assert.strictEqual(createUser.params[0].schema.type, 'string');
             assert.strictEqual(createUser.params[1].schema.type, 'number');
@@ -94,9 +133,34 @@ describe('extractSkipCodegenMethods — pure-AST scan', () => {
         try {
             const skips = extractSkipCodegenMethods(join(dir, 'index.ts'));
             assert.strictEqual(skips.size, 1);
-            assert.ok(skips.has('devOnly'));
-            assert.ok(!skips.has('normalMethod'));
-            assert.ok(!skips.has('alsoNormal'));
+            assert.ok(skips.has('api.devOnly'), 'skip set is namespace-qualified');
+            assert.ok(!skips.has('api.normalMethod'));
+            assert.ok(!skips.has('api.alsoNormal'));
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it('qualifies skip names by namespace so a tag on one namespace does not drop another (regression: #445)', () => {
+        const dir = createTempProject({
+            'index.ts': `
+				class ApiNamespace { constructor(scope: any, name: any, handler: any) {} }
+
+				export const widgets = new ApiNamespace(null, 'widgets', () => ({
+					/** @blocksSkipCodegen */
+					async create() { return null; },
+				}));
+				// subscriptions.create is NOT tagged and must survive.
+				export const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({
+					async create() { return null; },
+				}));
+			`,
+        });
+        try {
+            const skips = extractSkipCodegenMethods(join(dir, 'index.ts'));
+            assert.ok(skips.has('widgets.create'), 'tagged method is skipped, qualified');
+            assert.ok(!skips.has('subscriptions.create'), 'untagged same-named method must NOT be skipped');
+            assert.ok(!skips.has('create'), 'no bare key that would drop both');
         }
         finally {
             rmSync(dir, { recursive: true, force: true });
@@ -146,8 +210,8 @@ describe('extractMethodTypes — @blocksSkipCodegen JSDoc tag', () => {
         });
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
-            assert.strictEqual(types.get('normalMethod')?.skipCodegen, undefined);
-            assert.strictEqual(types.get('getLastCode')?.skipCodegen, true);
+            assert.strictEqual(types.get('api.normalMethod')?.skipCodegen, undefined);
+            assert.strictEqual(types.get('api.getLastCode')?.skipCodegen, true);
         }
         finally {
             rmSync(dir, { recursive: true, force: true });
@@ -206,20 +270,20 @@ describe('extractMethodTypes — indirect ApiNamespace calls (e.g., auth.createA
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
             // Direct ApiNamespace methods should still work
-            assert.ok(types.has('greet'), 'should find greet from direct ApiNamespace');
-            const greet = types.get('greet');
+            assert.ok(types.has('api.greet'), 'should find greet from direct ApiNamespace');
+            const greet = types.get('api.greet');
             assert.strictEqual(greet.params[0].name, 'name');
             assert.strictEqual(greet.params[0].schema.type, 'string');
             // Indirect methods from auth.createApi() should now be resolved
-            assert.ok(types.has('getAuthState'), 'should find getAuthState from auth.createApi()');
-            assert.ok(types.has('setAuthState'), 'should find setAuthState from auth.createApi()');
-            const getAuthState = types.get('getAuthState');
+            assert.ok(types.has('authApi.getAuthState'), 'should find getAuthState from auth.createApi()');
+            assert.ok(types.has('authApi.setAuthState'), 'should find setAuthState from auth.createApi()');
+            const getAuthState = types.get('authApi.getAuthState');
             assert.strictEqual(getAuthState.params.length, 0, 'getAuthState has no params');
             assert.strictEqual(getAuthState.returnType.type, 'object', 'return type should be object');
             assert.ok(getAuthState.returnType.properties, 'return type should have properties');
             assert.ok('isSignedIn' in getAuthState.returnType.properties, 'should have isSignedIn');
             assert.ok('username' in getAuthState.returnType.properties, 'should have username');
-            const setAuthState = types.get('setAuthState');
+            const setAuthState = types.get('authApi.setAuthState');
             assert.strictEqual(setAuthState.params.length, 2, 'setAuthState has 2 params');
             assert.strictEqual(setAuthState.params[0].name, 'action');
             assert.strictEqual(setAuthState.params[0].schema.type, 'string');
@@ -255,9 +319,9 @@ describe('extractMethodTypes — indirect ApiNamespace calls (e.g., auth.createA
         });
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
-            assert.ok(types.has('greet'), 'should find greet');
+            assert.ok(types.has('api.greet'), 'should find greet');
             // The AST-walk version should be preserved (it has richer info from the declaration)
-            assert.strictEqual(types.get('greet').params[0].name, 'name');
+            assert.strictEqual(types.get('api.greet').params[0].name, 'name');
         }
         finally {
             rmSync(dir, { recursive: true, force: true });
@@ -315,7 +379,7 @@ describe('extractMethodTypes — transferable detection', () => {
 			`,
         });
         try {
-            const info = extractMethodTypes(join(dir, 'index.ts')).get('getCursorChannel');
+            const info = extractMethodTypes(join(dir, 'index.ts')).get('api.getCursorChannel');
             assert.ok(info, 'method should be discovered');
             assert.ok(info.transferable, 'should be detected as transferable');
             assert.strictEqual(info.transferable.blocksTag, 'realtime/channel');
@@ -340,7 +404,7 @@ describe('extractMethodTypes — transferable detection', () => {
 			`,
         });
         try {
-            const info = extractMethodTypes(join(dir, 'index.ts')).get('getDownload');
+            const info = extractMethodTypes(join(dir, 'index.ts')).get('api.getDownload');
             assert.ok(info?.transferable);
             assert.strictEqual(info.transferable.blocksTag, 'file-bucket/download');
             assert.deepStrictEqual(info.transferable.typeArgs, []);
@@ -362,8 +426,8 @@ describe('extractMethodTypes — transferable detection', () => {
         });
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
-            assert.deepStrictEqual(types.get('defaulted')?.transferable?.typeArgs, []);
-            assert.deepStrictEqual(types.get('explicit')?.transferable?.typeArgs, [{}]);
+            assert.deepStrictEqual(types.get('api.defaulted')?.transferable?.typeArgs, []);
+            assert.deepStrictEqual(types.get('api.explicit')?.transferable?.typeArgs, [{}]);
         }
         finally {
             rmSync(dir, { recursive: true, force: true });
@@ -384,8 +448,8 @@ describe('extractMethodTypes — transferable detection', () => {
         });
         try {
             const types = extractMethodTypes(join(dir, 'index.ts'));
-            assert.strictEqual(types.get('plain')?.transferable, undefined);
-            assert.strictEqual(types.get('loose')?.transferable, undefined);
+            assert.strictEqual(types.get('api.plain')?.transferable, undefined);
+            assert.strictEqual(types.get('api.loose')?.transferable, undefined);
         }
         finally {
             rmSync(dir, { recursive: true, force: true });
@@ -411,7 +475,7 @@ describe('extractMethodTypes — transferable detection', () => {
 			`,
         });
         try {
-            const info = extractMethodTypes(join(dir, 'index.ts')).get('getNotifications');
+            const info = extractMethodTypes(join(dir, 'index.ts')).get('api.getNotifications');
             assert.ok(info?.transferable);
             assert.strictEqual(info.transferable.blocksTag, 'realtime/channel');
             assert.strictEqual(info.transferable.typeArgs[0]?.title, 'Notification');
@@ -445,7 +509,7 @@ describe('extractMethodTypes — open-shape intersections', () => {
 			`,
         });
         try {
-            const info = extractMethodTypes(join(dir, 'index.ts')).get('signUp');
+            const info = extractMethodTypes(join(dir, 'index.ts')).get('api.signUp');
             assert.ok(info, 'should find signUp');
             const inputSchema = info.params[0].schema;
             assert.strictEqual(inputSchema.type, 'object');
@@ -482,7 +546,7 @@ describe('extractMethodTypes — open-shape intersections', () => {
 			`,
         });
         try {
-            const info = extractMethodTypes(join(dir, 'index.ts')).get('tag');
+            const info = extractMethodTypes(join(dir, 'index.ts')).get('api.tag');
             assert.ok(info, 'should find tag');
             const inputSchema = info.params[0].schema;
             assert.strictEqual(inputSchema.type, 'object');
@@ -495,3 +559,138 @@ describe('extractMethodTypes — open-shape intersections', () => {
         }
     });
 });
+describe('extractMethodTypes — namespace returned by a factory, then destructured (regression: #444)', () => {
+    it('keys a destructured factory namespace qualified, with real schemas', () => {
+        const dir = createTempProject({
+            'tsconfig.json': JSON.stringify({
+                compilerOptions: { target: 'ESNext', module: 'ESNext', moduleResolution: 'bundler', strict: true },
+            }),
+            'index.ts': `
+				${API_NS_MOCK}
+				class Scope { constructor(id: string) {} }
+
+				class NamespaceFactory {
+					constructor(private readonly scope: Scope) {}
+					createNamespaces() {
+						return {
+							indirectNamespace: new ApiNamespace(this.scope, 'indirectNamespace', () => ({
+								async getIndirectGreeting(times: number): Promise<string> { return 'hi'; },
+							})),
+						};
+					}
+				}
+
+				const scope = new Scope('repro');
+				export const directNamespace = new ApiNamespace(scope, 'directNamespace', () => ({
+					async getDirectGreeting(name: string): Promise<number> { return name.length; },
+				}));
+				const { indirectNamespace } = new NamespaceFactory(scope).createNamespaces();
+				export { indirectNamespace };
+			`,
+        });
+        try {
+            const types = extractMethodTypes(join(dir, 'index.ts'));
+            // The factory-returned namespace is now attributed to its binding name,
+            // exactly like the directly-constructed one.
+            const indirect = types.get('indirectNamespace.getIndirectGreeting');
+            assert.ok(indirect, 'indirectNamespace.getIndirectGreeting should be keyed by namespace');
+            assert.strictEqual(indirect.params[0].schema.type, 'number');
+            assert.strictEqual(indirect.returnType.type, 'string');
+            const direct = types.get('directNamespace.getDirectGreeting');
+            assert.ok(direct, 'directNamespace.getDirectGreeting should be present');
+            assert.strictEqual(direct.params[0].schema.type, 'string');
+            assert.strictEqual(direct.returnType.type, 'number');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it('a factory namespace sharing a method name with a direct one does NOT cross-assign', () => {
+        const dir = createTempProject({
+            'tsconfig.json': JSON.stringify({
+                compilerOptions: { target: 'ESNext', module: 'ESNext', moduleResolution: 'bundler', strict: true },
+            }),
+            'index.ts': `
+				${API_NS_MOCK}
+				class Scope { constructor(id: string) {} }
+
+				class Factory {
+					constructor(private readonly scope: Scope) {}
+					build() {
+						return {
+							subscriptions: new ApiNamespace(this.scope, 'subscriptions', () => ({
+								async create(topicCount: number): Promise<{ subId: number }> { return { subId: 1 }; },
+							})),
+						};
+					}
+				}
+
+				const scope = new Scope('app');
+				export const widgets = new ApiNamespace(scope, 'widgets', () => ({
+					async create(label: string): Promise<{ widgetId: string }> { return { widgetId: 'w' }; },
+				}));
+				const { subscriptions } = new Factory(scope).build();
+				export { subscriptions };
+			`,
+        });
+        try {
+            const types = extractMethodTypes(join(dir, 'index.ts'));
+            // Each namespace keeps its OWN param type under a distinct qualified key.
+            assert.strictEqual(types.get('widgets.create')?.params[0].schema?.type, 'string');
+            assert.strictEqual(types.get('subscriptions.create')?.params[0].schema?.type, 'number');
+            // The first-pass AST walk still emits a lingering bare `create` for the
+            // factory namespace, but it never overrides a qualified key: the
+            // direct namespace's qualified `widgets.create` is unaffected above, and
+            // `generate-spec` prefers the qualified key (see the collision test in
+            // generate-spec.test.ts, which asserts this end-to-end in the output).
+            // So the bare entry can't reintroduce the #445 cross-assignment here.
+            assert.strictEqual(types.get('widgets.create')?.params[0].schema?.type, 'string');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it('array/nested destructuring falls through to the bare key (documented boundary)', () => {
+        // Only a top-level identifier and a shallow object binding pattern are
+        // attributed to a namespace. An array pattern (`const [ns] = factory()`)
+        // falls through to the bare-key path — the schema is still recovered (the
+        // AST walk found `new ApiNamespace(...)`), just under the bare method name,
+        // which generate-spec's #498 fallback resolves when there's no collision.
+        const dir = createTempProject({
+            'tsconfig.json': JSON.stringify({
+                compilerOptions: { target: 'ESNext', module: 'ESNext', moduleResolution: 'bundler', strict: true },
+            }),
+            'index.ts': `
+				${API_NS_MOCK}
+				class Scope { constructor(id: string) {} }
+
+				class Factory {
+					constructor(private readonly scope: Scope) {}
+					build() {
+						return [
+							new ApiNamespace(this.scope, 'tupleNs', () => ({
+								async ping(count: number): Promise<string> { return 'p'; },
+							})),
+						] as const;
+					}
+				}
+				const scope = new Scope('app');
+				const [tupleNs] = new Factory(scope).build();
+				export { tupleNs };
+			`,
+        });
+        try {
+            const types = extractMethodTypes(join(dir, 'index.ts'));
+            // Not attributed to the binding (array pattern), so no qualified key…
+            assert.ok(!types.has('tupleNs.ping'), 'array pattern is not attributed (documented boundary)');
+            // …but the schema is still present under the bare name (soft fallback).
+            const bare = types.get('ping');
+            assert.ok(bare, 'method schema is still recovered under the bare key');
+            assert.strictEqual(bare.params[0].schema?.type, 'number');
+            assert.strictEqual(bare.returnType?.type, 'string');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/scripts/generate-spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate-spec.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-spec.ts"],"names":[],"mappings":"AA2BA,UAAU,eAAe;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;KAAE,CAAC;CACtD;AAED,UAAU,aAAa;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;CACtB;AAED,UAAU,YAAY;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;CACnB;AAED,UAAU,aAAa;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;CACnB;AAED,UAAU,UAAU;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAsKD;;;;;;;;;;;GAWG;AACH;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAIrF,wBAAsB,YAAY,CACjC,cAAc,EAAE,MAAM,EACtB,MAAM,GAAE,gBAAgC,GACtC,OAAO,CAAC,eAAe,CAAC,CAsQ1B;AAyQD;;;GAGG;AACH,wBAAsB,SAAS,CAC9B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CA0Bf"}
+{"version":3,"file":"generate-spec.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-spec.ts"],"names":[],"mappings":"AA2BA,UAAU,eAAe;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC1C,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;KAAE,CAAC;CACtD;AAED,UAAU,aAAa;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;CACtB;AAED,UAAU,YAAY;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;CACnB;AAED,UAAU,aAAa;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;CACnB;AAED,UAAU,UAAU;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAsKD;;;;;;;;;;;GAWG;AACH;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAIrF,wBAAsB,YAAY,CACjC,cAAc,EAAE,MAAM,EACtB,MAAM,GAAE,gBAAgC,GACtC,OAAO,CAAC,eAAe,CAAC,CAgR1B;AAyQD;;;GAGG;AACH,wBAAsB,SAAS,CAC9B,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/scripts/generate-spec.js

@@ -257,6 +257,15 @@ export async function generateSpec(foundationPath, loader = defaultLoader) {
         for (const [methodName, methodFn] of Object.entries(methodMap)) {
             if (typeof methodFn !== 'function')
                 continue;
+            const qualifiedName = `${routingName}.${methodName}`;
+            // Prefer the namespace-qualified TS types; fall back to the bare method
+            // name for entries the extractor couldn't attribute to a namespace.
+            // Qualified keys stop two namespaces that share a method name (e.g.
+            // widgets.create / subscriptions.create) from cross-assigning schemas.
+            // Residual edge: namespaces the extractor can't attribute (default export,
+            // factory-wrapped, or an `export { x as y }` rename) still land on bare
+            // keys and could overwrite each other here — same class as #445, but rare.
+            const tsInfo = tsTypes.get(qualifiedName) ?? tsTypes.get(methodName);
             // `@blocksSkipCodegen` is a JSDoc tag the customer puts on a method
             // they want callable from the generated TS client (Proxy-based,
             // doesn't enumerate) but absent from the OpenRPC spec — so native
@@ -267,9 +276,11 @@ export async function generateSpec(foundationPath, loader = defaultLoader) {
             // type-resolution errors and silently empty its Map — we always
             // want the JSDoc tag to be honored, so the AST-only scan acts as
             // a safety net.
-            if (tsTypes.get(methodName)?.skipCodegen || skipCodegenNames.has(methodName))
+            // The skip set is namespace-qualified too (with a bare fallback), so a
+            // `@blocksSkipCodegen` tag on one namespace's method doesn't drop another
+            // namespace's same-named method.
+            if (tsInfo?.skipCodegen || skipCodegenNames.has(qualifiedName) || skipCodegenNames.has(methodName))
                 continue;
-            const qualifiedName = `${routingName}.${methodName}`;
             const resultName = capitalize(methodName) + 'Result';
             const paramNames = extractParamNames(methodFn);
             const fnSource = methodFn.toString();
@@ -305,7 +316,6 @@ export async function generateSpec(foundationPath, loader = defaultLoader) {
             }
             else {
                 // No Zod schema — fall back to TypeScript AST types
-                const tsInfo = tsTypes.get(methodName);
                 if (tsInfo) {
                     params = tsInfo.params.map((p) => ({
                         name: p.name,
@@ -322,8 +332,7 @@ export async function generateSpec(foundationPath, loader = defaultLoader) {
                     }));
                 }
             }
-            // Return type: Zod doesn't cover this yet, so use TS types
-            const tsInfo = tsTypes.get(methodName);
+            // Return type: Zod doesn't cover this yet, so use TS types (tsInfo resolved above)
             const rawResultSchema = tsInfo?.returnType && tsInfo.returnType.type !== 'unknown'
                 ? tsInfo.returnType
                 : { type: 'unknown' };

package/dist/scripts/generate-spec.test.js

@@ -15,6 +15,7 @@ import { join, dirname } from 'path';
 import { tmpdir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { generateSpec } from './generate-spec.js';
+import { ApiNamespace } from '../api.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // `import.meta.url` lives in dist/scripts/, so `..` is dist/ and the built
 // `api.js` is next to it. Re-using the real ApiNamespace ensures the marker
@@ -86,3 +87,95 @@ describe('generateSpec — @blocksSkipCodegen', () => {
         }
     });
 });
+describe('generateSpec — namespaces sharing a method name (regression: #445)', () => {
+    it('emits each namespace its OWN schema for a same-named method', async () => {
+        const dir = join(tmpdir(), `blocks-spec-test-${Date.now()}-collision`);
+        mkdirSync(dir, { recursive: true });
+        writeTsconfig(dir);
+        // Typed foundation for the TS type extractor. `create` has DIFFERENT params
+        // in each namespace; binding names (widgets/subscriptions) match the runtime
+        // module's export names below.
+        writeFileSync(join(dir, 'index.ts'), `
+			interface ApiNamespaceConstructor { new <T>(scope: any, name: string, handler: (ctx: any) => T): T; }
+			const ApiNamespace: ApiNamespaceConstructor = class {} as any;
+
+			export const widgets = new ApiNamespace(null, 'widgets', () => ({
+				async create(label: string): Promise<{ widgetId: string }> { return { widgetId: 'w' }; },
+			}));
+			export const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({
+				async create(topicCount: number): Promise<{ subId: number }> { return { subId: 1 }; },
+			}));
+		`);
+        // Runtime module for namespace discovery (types come from the .ts above via
+        // the extractor). Use the real ApiNamespace so the marker symbol matches.
+        const widgets = new ApiNamespace(null, 'widgets', () => ({ async create(_label) { return { widgetId: 'w' }; } }));
+        const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({ async create(_topicCount) { return { subId: 1 }; } }));
+        const loader = async () => ({ widgets, subscriptions });
+        try {
+            const doc = await generateSpec(join(dir, 'index.ts'), loader);
+            const byName = new Map(doc.methods.map((m) => [m.name, m]));
+            const w = byName.get('widgets.create');
+            const s = byName.get('subscriptions.create');
+            assert.ok(w && s, 'both namespace-qualified methods should be present');
+            // Each keeps its OWN param — no cross-assignment.
+            assert.strictEqual(w.params[0]?.name, 'label');
+            assert.strictEqual(w.params[0]?.schema?.type, 'string');
+            assert.strictEqual(s.params[0]?.name, 'topicCount');
+            assert.strictEqual(s.params[0]?.schema?.type, 'number');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('generateSpec — namespace returned by a factory, then destructured (regression: #444)', () => {
+    it('emits real schemas (not unknown) for a factory/destructured namespace', async () => {
+        const dir = join(tmpdir(), `blocks-spec-test-${Date.now()}-factory`);
+        mkdirSync(dir, { recursive: true });
+        writeTsconfig(dir);
+        // Typed foundation: one directly-exported namespace and one built inside a
+        // factory, returned as a property, destructured, and re-exported. Both use
+        // `create` with DIFFERENT params so a regression would cross-assign or emit
+        // unknown.
+        writeFileSync(join(dir, 'index.ts'), `
+			interface ApiNamespaceConstructor { new <T>(scope: any, name: string, handler: (ctx: any) => T): T; }
+			const ApiNamespace: ApiNamespaceConstructor = class {} as any;
+			class Scope { constructor(id: string) {} }
+
+			class Factory {
+				constructor(private readonly scope: Scope) {}
+				build() {
+					return {
+						subscriptions: new ApiNamespace(this.scope, 'subscriptions', () => ({
+							async create(topicCount: number): Promise<{ subId: number }> { return { subId: 1 }; },
+						})),
+					};
+				}
+			}
+
+			const scope = new Scope('app');
+			export const widgets = new ApiNamespace(scope, 'widgets', () => ({
+				async create(label: string): Promise<{ widgetId: string }> { return { widgetId: 'w' }; },
+			}));
+			const { subscriptions } = new Factory(scope).build();
+			export { subscriptions };
+		`);
+        const widgets = new ApiNamespace(null, 'widgets', () => ({ async create(_label) { return { widgetId: 'w' }; } }));
+        const subscriptions = new ApiNamespace(null, 'subscriptions', () => ({ async create(_topicCount) { return { subId: 1 }; } }));
+        const loader = async () => ({ widgets, subscriptions });
+        try {
+            const doc = await generateSpec(join(dir, 'index.ts'), loader);
+            const byName = new Map(doc.methods.map((m) => [m.name, m]));
+            const w = byName.get('widgets.create');
+            const s = byName.get('subscriptions.create');
+            assert.ok(w && s, 'both qualified methods present');
+            // The factory-returned namespace keeps its own param, not `unknown` and
+            // not the direct namespace's `string`.
+            assert.strictEqual(s.params[0]?.schema?.type, 'number');
+            assert.strictEqual(w.params[0]?.schema?.type, 'string');
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/scripts/sandbox-empty-buckets.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sandbox-empty-buckets.test.d.ts.map

package/dist/scripts/sandbox-empty-buckets.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox-empty-buckets.test.d.ts","sourceRoot":"","sources":["../../src/scripts/sandbox-empty-buckets.test.ts"],"names":[],"mappings":""}