@happyvertical/smrt-core 0.46.0 → 0.47.0

package/AGENTS.md

@@ -53,6 +53,44 @@ and repository rules.
   constructor, explicit package, and isolated one-object manifest. Never infer
   ownership from paths, simple names, or table names; packages can share names.
   Consumer regression gate: `packages/bundle-gate/src/__tests__/registry-identity.spec.ts`.
+- API custom-action eligibility has ONE resolver, `resolveApiMethodExposure()`
+  in `generators/custom-action.ts`: both SvelteKit route emitters,
+  `resolveApiActionSet`, and `knowledge.ts` read it, and a new consumer must too
+  — a local mirror is how a method gets reported unavailable while its route
+  file is still written. A public method routes by default only when every
+  parameter is JSON-shaped; `@method({ expose })` overrides in both directions,
+  `expose: true` bypasses the heuristic ALONE, and an explicit `api.include` or
+  `api.routes` entry keeps its pre-#2686 route. Fail closed on scanner
+  uncertainty: read `parameters[].typeUnresolved`, never the `'any'` it
+  substitutes. Accepting `Date` as wire-able and hydrating it
+  (`toCustomActionDate`) are one decision — changing either breaks the other.
+  The runtime `APIGenerator` transport stays declaration-gated: `rest.ts`
+  dispatch and `preflight-route.ts` prediction both read
+  `declaresRuntimeRestRoute()`, which must accept every `ApiCustomRouteConfig`
+  option so a sweep moving one onto its method cannot delete the endpoint. Its
+  twin `declaresRuntimeRestRouteShape()` deliberately ignores `expose: false`:
+  the dispatcher must still SEE a withheld declaration to answer 404, because
+  `POST /<collection>/<segment>` resolves to `create` when nothing claims the
+  segment. Split unions and type arguments with `splitTopLevel()` — a naive
+  `split('|')` truncates `Record<string, Asset | null>` into fragments that
+  match no rule and are then accepted, widening the gate. `extractTypeName`
+  returns `null` for a generic with an unresolvable ARGUMENT or a union with an
+  unresolvable BRANCH so those reach that fail-closed path instead of arriving
+  as a bare `'Array'`. Runtime transports read
+  `ObjectRegistry.resolveRuntimeMethod()`, which tries the item class's manifest
+  entry, then the COLLECTION class's (where a collection-hosted action's
+  parameters live), then the live `@method()` store — keyed by CONSTRUCTOR,
+  never by simple name (`Account` exists in two packages), and recording
+  `isStatic` because an unscanned runtime has no manifest to recover the
+  receiver from. `isRestActionRoutable` ANDs "declared" with that receiver, so
+  it never predicts `allow` for an action dispatch refuses. A declared action
+  with no receiver is refused (501 collection-scoped, 404 item-scoped), never
+  allowed to fall through into `create`. All eight consumers read the resolver,
+  including `packages/smrt-workbench/src/discovery.ts`; it imports the
+  `./generators/custom-action` LEAF subpath, not `./generators`, because that
+  barrel value-re-exports `MCPGenerator` and so drags `@happyvertical/ai` and
+  `@happyvertical/sql` into a build-time helper (2 modules vs 109). Keep
+  `custom-action.ts` free of value imports outside `tools/tool-generator`.
 
 ## Gotchas
 

package/dist/decorators/compatibility.d.ts

@@ -8,7 +8,53 @@ export interface CompatiblePropertyDecorator<This = unknown, Value = unknown> {
     (target: object, propertyKey: string | symbol): void;
     (value: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
 }
+/**
+ * A method decorator that works under BOTH decorator implementations, the same
+ * way {@link CompatiblePropertyDecorator} does for class fields.
+ *
+ * Legacy (TypeScript `experimentalDecorators`, and the Oxc legacy mode this
+ * repo builds with) calls `(target, propertyKey, descriptor)`, where `target`
+ * is the prototype for an instance method and the constructor for a static
+ * one. TC39 standard decorators call `(value, context)`. Returning `void` from
+ * either leaves the method untouched, which is all a metadata-only decorator
+ * needs (#2686).
+ */
+/**
+ * The constraint `ClassMethodDecoratorContext<This, Value>` imposes on its
+ * `Value`, restated so this module's own generics can satisfy it. Any narrower
+ * spelling (`...args: never`, `unknown[]`) is rejected by the lib type, and a
+ * method decorator has to accept every method signature anyway.
+ */
+type AnyMethodOf<This> = (this: This, ...args: any) => any;
+type AnyMethod = (this: any, ...args: any) => any;
+export type CompatibleMethodDecoratorContext<This, Value extends AnyMethodOf<This>> = string | symbol | ClassMethodDecoratorContext<This, Value>;
+export interface CompatibleMethodDecorator<This = unknown, Value extends AnyMethodOf<This> = AnyMethod> {
+    (target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void;
+    (value: Value, context: ClassMethodDecoratorContext<This, Value>): void;
+}
 export declare function resolveDecoratorClassName(target: unknown): string | undefined;
 export declare function applyPendingDecoratorRegistrations(target: Function, decoratorContext?: ClassDecoratorContext): void;
+/**
+ * Register a method decorator's metadata under the decorated class's name,
+ * under whichever decorator implementation is running.
+ *
+ * The class-field twin below is the model, but the two cannot share one
+ * function: their legacy signatures differ (a method decorator receives a
+ * property descriptor as a third argument), and a static method's legacy
+ * `target` is the CONSTRUCTOR while an instance method's is the prototype —
+ * `getDecoratorConstructor` already handles both, which is why the receiver
+ * resolution is shared even though the entry point is not.
+ *
+ * Registration is keyed by the CONSTRUCTOR, not by its name: two packages may
+ * legitimately declare a class with the same simple name (`Account` exists in
+ * both `smrt-ledgers` and `smrt-messages`), and the kernel forbids inferring
+ * ownership from simple names. A name-keyed store would let one package's
+ * `@method({ expose: false })` withhold the other's identically-named action.
+ *
+ * Metadata-only: nothing is wrapped and nothing is returned, so the decorated
+ * method keeps its identity and remains directly callable (#2686).
+ */
+export declare function registerCompatibleMethodDecorator<This, Value extends AnyMethodOf<This>>(targetOrValue: LegacyPropertyDecoratorTarget | Value | undefined, propertyKeyOrContext: CompatibleMethodDecoratorContext<This, Value>, registerMethodDecorator: (ctor: Function, methodName: string, isStatic: boolean) => void): void;
 export declare function registerCompatibleFieldDecorator<This, Value>(targetOrValue: LegacyPropertyDecoratorTarget | undefined, propertyKeyOrContext: CompatiblePropertyDecoratorContext<This, Value>, registerFieldDecorator: (className: string, propertyKey: string) => void): void;
+export {};
 //# sourceMappingURL=compatibility.d.ts.map

package/dist/decorators/compatibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../src/decorators/compatibility.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,WAAW,CAAC,EAAE,QAAQ,GAAG;QACvB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,kCAAkC,CAAC,IAAI,EAAE,KAAK,IACtD,MAAM,GACN,MAAM,GACN,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAE5C,MAAM,WAAW,2BAA2B,CAAC,IAAI,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAC1E,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACrD,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;CAC5E;AA2FD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU7E;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,QAAQ,EAChB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,IAAI,CAsBN;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,KAAK,EAC1D,aAAa,EAAE,6BAA6B,GAAG,SAAS,EACxD,oBAAoB,EAAE,kCAAkC,CAAC,IAAI,EAAE,KAAK,CAAC,EACrE,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GACvE,IAAI,CAiCN"}
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../src/decorators/compatibility.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,WAAW,CAAC,EAAE,QAAQ,GAAG;QACvB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,kCAAkC,CAAC,IAAI,EAAE,KAAK,IACtD,MAAM,GACN,MAAM,GACN,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAE5C,MAAM,WAAW,2BAA2B,CAAC,IAAI,GAAG,OAAO,EAAE,KAAK,GAAG,OAAO;IAC1E,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACrD,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;CAC5E;AAED;;;;;;;;;;GAUG;AACH;;;;;GAKG;AAEH,KAAK,WAAW,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;AAG3D,KAAK,SAAS,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;AAElD,MAAM,MAAM,gCAAgC,CAC1C,IAAI,EACJ,KAAK,SAAS,WAAW,CAAC,IAAI,CAAC,IAC7B,MAAM,GAAG,MAAM,GAAG,2BAA2B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAE/D,MAAM,WAAW,yBAAyB,CACxC,IAAI,GAAG,OAAO,EACd,KAAK,SAAS,WAAW,CAAC,IAAI,CAAC,GAAG,SAAS;IAE3C,CACE,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,EAC5B,UAAU,CAAC,EAAE,kBAAkB,GAC9B,IAAI,CAAC;IACR,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,2BAA2B,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC;CACzE;AA4FD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU7E;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,QAAQ,EAChB,gBAAgB,CAAC,EAAE,qBAAqB,GACvC,IAAI,CAsBN;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EACJ,KAAK,SAAS,WAAW,CAAC,IAAI,CAAC,EAE/B,aAAa,EAAE,6BAA6B,GAAG,KAAK,GAAG,SAAS,EAChE,oBAAoB,EAAE,gCAAgC,CAAC,IAAI,EAAE,KAAK,CAAC,EACnE,uBAAuB,EAAE,CACvB,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,KACd,IAAI,GACR,IAAI,CA8CN;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,KAAK,EAC1D,aAAa,EAAE,6BAA6B,GAAG,SAAS,EACxD,oBAAoB,EAAE,kCAAkC,CAAC,IAAI,EAAE,KAAK,CAAC,EACrE,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,KAAK,IAAI,GACvE,IAAI,CAqCN"}

package/dist/decorators/compatibility.js

@@ -46,10 +46,51 @@ function applyPendingDecoratorRegistrations(target, decoratorContext) {
 	if (!pendingDecorators || pendingDecorators.length === 0) return;
 	for (const { register } of pendingDecorators) {
 		if (!markStandardDecoratorRegistration(target, register)) continue;
-		register(target.name);
+		register(target);
 	}
 	Reflect.deleteProperty(metadata, PENDING_FIELD_DECORATORS_KEY);
 }
+/**
+* Register a method decorator's metadata under the decorated class's name,
+* under whichever decorator implementation is running.
+*
+* The class-field twin below is the model, but the two cannot share one
+* function: their legacy signatures differ (a method decorator receives a
+* property descriptor as a third argument), and a static method's legacy
+* `target` is the CONSTRUCTOR while an instance method's is the prototype —
+* `getDecoratorConstructor` already handles both, which is why the receiver
+* resolution is shared even though the entry point is not.
+*
+* Registration is keyed by the CONSTRUCTOR, not by its name: two packages may
+* legitimately declare a class with the same simple name (`Account` exists in
+* both `smrt-ledgers` and `smrt-messages`), and the kernel forbids inferring
+* ownership from simple names. A name-keyed store would let one package's
+* `@method({ expose: false })` withhold the other's identically-named action.
+*
+* Metadata-only: nothing is wrapped and nothing is returned, so the decorated
+* method keeps its identity and remains directly callable (#2686).
+*/
+function registerCompatibleMethodDecorator(targetOrValue, propertyKeyOrContext, registerMethodDecorator) {
+	if (typeof propertyKeyOrContext === "string" || typeof propertyKeyOrContext === "symbol") {
+		const ctor = getDecoratorConstructor(targetOrValue);
+		if (ctor) registerMethodDecorator(ctor, String(propertyKeyOrContext), typeof targetOrValue === "function");
+		return;
+	}
+	const context = propertyKeyOrContext;
+	const methodName = String(context.name);
+	const isStatic = context.static === true;
+	const register = (ctor) => registerMethodDecorator(ctor, methodName, isStatic);
+	const metadata = getDecoratorMetadata(context);
+	if (metadata) {
+		queuePendingFieldDecorator(metadata, register);
+		return;
+	}
+	context.addInitializer?.(function registerSmrtMethodDecorator() {
+		if (!markStandardDecoratorRegistration(this, register)) return;
+		const ctor = getDecoratorConstructor(this);
+		if (ctor) register(ctor);
+	});
+}
 function registerCompatibleFieldDecorator(targetOrValue, propertyKeyOrContext, registerFieldDecorator) {
 	if (typeof propertyKeyOrContext === "string" || typeof propertyKeyOrContext === "symbol") {
 		const className = resolveDecoratorClassName(targetOrValue);
@@ -58,7 +99,9 @@ function registerCompatibleFieldDecorator(targetOrValue, propertyKeyOrContext, r
 	}
 	const context = propertyKeyOrContext;
 	const propertyKey = String(context.name);
-	const register = (className) => registerFieldDecorator(className, propertyKey);
+	const register = (ctor) => {
+		if (ctor.name) registerFieldDecorator(ctor.name, propertyKey);
+	};
 	const metadata = getDecoratorMetadata(context);
 	if (metadata) {
 		queuePendingFieldDecorator(metadata, register);
@@ -66,11 +109,11 @@ function registerCompatibleFieldDecorator(targetOrValue, propertyKeyOrContext, r
 	}
 	context.addInitializer?.(function registerSmrtDecorator() {
 		if (!markStandardDecoratorRegistration(this, register)) return;
-		const className = resolveDecoratorClassName(this);
-		if (className) register(className);
+		const ctor = getDecoratorConstructor(this);
+		if (ctor) register(ctor);
 	});
 }
 //#endregion
-export { applyPendingDecoratorRegistrations, registerCompatibleFieldDecorator, resolveDecoratorClassName };
+export { applyPendingDecoratorRegistrations, registerCompatibleFieldDecorator, registerCompatibleMethodDecorator, resolveDecoratorClassName };
 
 //# sourceMappingURL=compatibility.js.map

package/dist/decorators/compatibility.js.map

@@ -1 +1 @@
-{"version":3,"file":"compatibility.js","names":[],"sources":["../../src/decorators/compatibility.ts"],"sourcesContent":["type DecoratorMetadataStore = Record<PropertyKey, unknown>;\n\nconst PENDING_FIELD_DECORATORS_KEY = Symbol.for(\n  '@happyvertical/smrt-core/pending-field-decorators',\n);\nconst standardDecoratorRegistrations = new WeakMap<\n  Function,\n  WeakSet<(className: string) => void>\n>();\n\ntype PendingDecoratorRegistration = {\n  register: (className: string) => void;\n};\n\nexport type LegacyPropertyDecoratorTarget = {\n  constructor?: Function & {\n    name?: string;\n  };\n};\n\nexport type CompatiblePropertyDecoratorContext<This, Value> =\n  | string\n  | symbol\n  | ClassFieldDecoratorContext<This, Value>;\n\nexport interface CompatiblePropertyDecorator<This = unknown, Value = unknown> {\n  (target: object, propertyKey: string | symbol): void;\n  (value: undefined, context: ClassFieldDecoratorContext<This, Value>): void;\n}\n\nfunction getDecoratorConstructor(target: unknown): Function | undefined {\n  if (typeof target === 'function') {\n    return target;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor;\n  }\n\n  return undefined;\n}\n\nfunction markStandardDecoratorRegistration(\n  target: unknown,\n  register: (className: string) => void,\n): boolean {\n  const ctor = getDecoratorConstructor(target);\n  if (!ctor) {\n    return false;\n  }\n\n  const registeredCallbacks =\n    standardDecoratorRegistrations.get(ctor) ?? new WeakSet();\n  if (registeredCallbacks.has(register)) {\n    return false;\n  }\n\n  registeredCallbacks.add(register);\n  standardDecoratorRegistrations.set(ctor, registeredCallbacks);\n  return true;\n}\n\nfunction getDecoratorMetadata(\n  contextOrMetadata:\n    | ClassFieldDecoratorContext<unknown, unknown>\n    | ClassDecoratorContext\n    | DecoratorMetadataStore\n    | undefined,\n): DecoratorMetadataStore | undefined {\n  if (!contextOrMetadata || typeof contextOrMetadata !== 'object') {\n    return undefined;\n  }\n\n  if ('metadata' in contextOrMetadata) {\n    const { metadata } = contextOrMetadata as {\n      metadata?: DecoratorMetadataStore;\n    };\n    return metadata && typeof metadata === 'object' ? metadata : undefined;\n  }\n\n  return contextOrMetadata;\n}\n\nfunction getClassDecoratorMetadata(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): DecoratorMetadataStore | undefined {\n  const metadataFromContext = getDecoratorMetadata(decoratorContext);\n  if (metadataFromContext) {\n    return metadataFromContext;\n  }\n\n  const metadataSymbol = (Symbol as typeof Symbol & { metadata?: symbol })\n    .metadata;\n  if (!metadataSymbol) {\n    return undefined;\n  }\n\n  const metadata = (target as unknown as Record<PropertyKey, unknown>)[\n    metadataSymbol\n  ];\n  return metadata && typeof metadata === 'object'\n    ? (metadata as DecoratorMetadataStore)\n    : undefined;\n}\n\nfunction queuePendingFieldDecorator(\n  metadata: DecoratorMetadataStore,\n  register: (className: string) => void,\n): void {\n  const pendingDecorators =\n    (metadata[PENDING_FIELD_DECORATORS_KEY] as\n      | PendingDecoratorRegistration[]\n      | undefined) ?? [];\n\n  pendingDecorators.push({ register });\n  metadata[PENDING_FIELD_DECORATORS_KEY] = pendingDecorators;\n}\n\nexport function resolveDecoratorClassName(target: unknown): string | undefined {\n  if (typeof target === 'function') {\n    return target.name;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor?.name;\n  }\n\n  return undefined;\n}\n\nexport function applyPendingDecoratorRegistrations(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): void {\n  const metadata = getClassDecoratorMetadata(target, decoratorContext);\n  if (!metadata) {\n    return;\n  }\n\n  const pendingDecorators = metadata[PENDING_FIELD_DECORATORS_KEY] as\n    | PendingDecoratorRegistration[]\n    | undefined;\n  if (!pendingDecorators || pendingDecorators.length === 0) {\n    return;\n  }\n\n  for (const { register } of pendingDecorators) {\n    if (!markStandardDecoratorRegistration(target, register)) {\n      continue;\n    }\n\n    register(target.name);\n  }\n\n  Reflect.deleteProperty(metadata, PENDING_FIELD_DECORATORS_KEY);\n}\n\nexport function registerCompatibleFieldDecorator<This, Value>(\n  targetOrValue: LegacyPropertyDecoratorTarget | undefined,\n  propertyKeyOrContext: CompatiblePropertyDecoratorContext<This, Value>,\n  registerFieldDecorator: (className: string, propertyKey: string) => void,\n): void {\n  if (\n    typeof propertyKeyOrContext === 'string' ||\n    typeof propertyKeyOrContext === 'symbol'\n  ) {\n    const className = resolveDecoratorClassName(targetOrValue);\n    if (className) {\n      registerFieldDecorator(className, String(propertyKeyOrContext));\n    }\n    return;\n  }\n\n  const context = propertyKeyOrContext;\n  const propertyKey = String(context.name);\n  const register = (className: string) =>\n    registerFieldDecorator(className, propertyKey);\n  const metadata = getDecoratorMetadata(context);\n\n  if (metadata) {\n    queuePendingFieldDecorator(metadata, register);\n    return;\n  }\n\n  context.addInitializer?.(function registerSmrtDecorator() {\n    if (!markStandardDecoratorRegistration(this, register)) {\n      return;\n    }\n\n    const className = resolveDecoratorClassName(this);\n    if (className) {\n      register(className);\n    }\n  });\n}\n"],"mappings":";AAEA,IAAM,+BAA+B,OAAO,IAC1C,mDACF;AACA,IAAM,iDAAiC,IAAI,QAGzC;AAsBF,SAAS,wBAAwB,QAAuC;CACtE,IAAI,OAAO,WAAW,YACpB,OAAO;CAGT,IAAI,UAAU,OAAO,WAAW,UAC9B,OAAQ,OAAyC;AAIrD;AAEA,SAAS,kCACP,QACA,UACS;CACT,MAAM,OAAO,wBAAwB,MAAM;CAC3C,IAAI,CAAC,MACH,OAAO;CAGT,MAAM,sBACJ,+BAA+B,IAAI,IAAI,qBAAK,IAAI,QAAQ;CAC1D,IAAI,oBAAoB,IAAI,QAAQ,GAClC,OAAO;CAGT,oBAAoB,IAAI,QAAQ;CAChC,+BAA+B,IAAI,MAAM,mBAAmB;CAC5D,OAAO;AACT;AAEA,SAAS,qBACP,mBAKoC;CACpC,IAAI,CAAC,qBAAqB,OAAO,sBAAsB,UACrD;CAGF,IAAI,cAAc,mBAAmB;EACnC,MAAM,EAAE,aAAa;EAGrB,OAAO,YAAY,OAAO,aAAa,WAAW,WAAW,KAAA;CAC/D;CAEA,OAAO;AACT;AAEA,SAAS,0BACP,QACA,kBACoC;CACpC,MAAM,sBAAsB,qBAAqB,gBAAgB;CACjE,IAAI,qBACF,OAAO;CAGT,MAAM,iBAAkB,OACrB;CACH,IAAI,CAAC,gBACH;CAGF,MAAM,WAAY,OAChB;CAEF,OAAO,YAAY,OAAO,aAAa,WAClC,WACD,KAAA;AACN;AAEA,SAAS,2BACP,UACA,UACM;CACN,MAAM,oBACH,SAAS,iCAEQ,CAAC;CAErB,kBAAkB,KAAK,EAAE,SAAS,CAAC;CACnC,SAAS,gCAAgC;AAC3C;AAEA,SAAgB,0BAA0B,QAAqC;CAC7E,IAAI,OAAO,WAAW,YACpB,OAAO,OAAO;CAGhB,IAAI,UAAU,OAAO,WAAW,UAC9B,OAAQ,OAAyC,aAAa;AAIlE;AAEA,SAAgB,mCACd,QACA,kBACM;CACN,MAAM,WAAW,0BAA0B,QAAQ,gBAAgB;CACnE,IAAI,CAAC,UACH;CAGF,MAAM,oBAAoB,SAAS;CAGnC,IAAI,CAAC,qBAAqB,kBAAkB,WAAW,GACrD;CAGF,KAAK,MAAM,EAAE,cAAc,mBAAmB;EAC5C,IAAI,CAAC,kCAAkC,QAAQ,QAAQ,GACrD;EAGF,SAAS,OAAO,IAAI;CACtB;CAEA,QAAQ,eAAe,UAAU,4BAA4B;AAC/D;AAEA,SAAgB,iCACd,eACA,sBACA,wBACM;CACN,IACE,OAAO,yBAAyB,YAChC,OAAO,yBAAyB,UAChC;EACA,MAAM,YAAY,0BAA0B,aAAa;EACzD,IAAI,WACF,uBAAuB,WAAW,OAAO,oBAAoB,CAAC;EAEhE;CACF;CAEA,MAAM,UAAU;CAChB,MAAM,cAAc,OAAO,QAAQ,IAAI;CACvC,MAAM,YAAY,cAChB,uBAAuB,WAAW,WAAW;CAC/C,MAAM,WAAW,qBAAqB,OAAO;CAE7C,IAAI,UAAU;EACZ,2BAA2B,UAAU,QAAQ;EAC7C;CACF;CAEA,QAAQ,iBAAiB,SAAS,wBAAwB;EACxD,IAAI,CAAC,kCAAkC,MAAM,QAAQ,GACnD;EAGF,MAAM,YAAY,0BAA0B,IAAI;EAChD,IAAI,WACF,SAAS,SAAS;CAEtB,CAAC;AACH"}
+{"version":3,"file":"compatibility.js","names":[],"sources":["../../src/decorators/compatibility.ts"],"sourcesContent":["type DecoratorMetadataStore = Record<PropertyKey, unknown>;\n\nconst PENDING_FIELD_DECORATORS_KEY = Symbol.for(\n  '@happyvertical/smrt-core/pending-field-decorators',\n);\nconst standardDecoratorRegistrations = new WeakMap<\n  Function,\n  WeakSet<(ctor: Function) => void>\n>();\n\ntype PendingDecoratorRegistration = {\n  register: (ctor: Function) => void;\n};\n\nexport type LegacyPropertyDecoratorTarget = {\n  constructor?: Function & {\n    name?: string;\n  };\n};\n\nexport type CompatiblePropertyDecoratorContext<This, Value> =\n  | string\n  | symbol\n  | ClassFieldDecoratorContext<This, Value>;\n\nexport interface CompatiblePropertyDecorator<This = unknown, Value = unknown> {\n  (target: object, propertyKey: string | symbol): void;\n  (value: undefined, context: ClassFieldDecoratorContext<This, Value>): void;\n}\n\n/**\n * A method decorator that works under BOTH decorator implementations, the same\n * way {@link CompatiblePropertyDecorator} does for class fields.\n *\n * Legacy (TypeScript `experimentalDecorators`, and the Oxc legacy mode this\n * repo builds with) calls `(target, propertyKey, descriptor)`, where `target`\n * is the prototype for an instance method and the constructor for a static\n * one. TC39 standard decorators call `(value, context)`. Returning `void` from\n * either leaves the method untouched, which is all a metadata-only decorator\n * needs (#2686).\n */\n/**\n * The constraint `ClassMethodDecoratorContext<This, Value>` imposes on its\n * `Value`, restated so this module's own generics can satisfy it. Any narrower\n * spelling (`...args: never`, `unknown[]`) is rejected by the lib type, and a\n * method decorator has to accept every method signature anyway.\n */\n// biome-ignore lint/suspicious/noExplicitAny: mirrors the lib's own `ClassMethodDecoratorContext` constraint; a narrower type does not satisfy it. Same rationale as `SmrtObjectConstructor` in registry/types.ts. S4 #1579.\ntype AnyMethodOf<This> = (this: This, ...args: any) => any;\n\n// biome-ignore lint/suspicious/noExplicitAny: see AnyMethodOf above. S4 #1579.\ntype AnyMethod = (this: any, ...args: any) => any;\n\nexport type CompatibleMethodDecoratorContext<\n  This,\n  Value extends AnyMethodOf<This>,\n> = string | symbol | ClassMethodDecoratorContext<This, Value>;\n\nexport interface CompatibleMethodDecorator<\n  This = unknown,\n  Value extends AnyMethodOf<This> = AnyMethod,\n> {\n  (\n    target: object,\n    propertyKey: string | symbol,\n    descriptor?: PropertyDescriptor,\n  ): void;\n  (value: Value, context: ClassMethodDecoratorContext<This, Value>): void;\n}\n\nfunction getDecoratorConstructor(target: unknown): Function | undefined {\n  if (typeof target === 'function') {\n    return target;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor;\n  }\n\n  return undefined;\n}\n\nfunction markStandardDecoratorRegistration(\n  target: unknown,\n  register: (ctor: Function) => void,\n): boolean {\n  const ctor = getDecoratorConstructor(target);\n  if (!ctor) {\n    return false;\n  }\n\n  const registeredCallbacks =\n    standardDecoratorRegistrations.get(ctor) ?? new WeakSet();\n  if (registeredCallbacks.has(register)) {\n    return false;\n  }\n\n  registeredCallbacks.add(register);\n  standardDecoratorRegistrations.set(ctor, registeredCallbacks);\n  return true;\n}\n\nfunction getDecoratorMetadata(\n  contextOrMetadata:\n    | ClassFieldDecoratorContext<unknown, unknown>\n    | ClassMethodDecoratorContext<unknown, AnyMethod>\n    | ClassDecoratorContext\n    | DecoratorMetadataStore\n    | undefined,\n): DecoratorMetadataStore | undefined {\n  if (!contextOrMetadata || typeof contextOrMetadata !== 'object') {\n    return undefined;\n  }\n\n  if ('metadata' in contextOrMetadata) {\n    const { metadata } = contextOrMetadata as {\n      metadata?: DecoratorMetadataStore;\n    };\n    return metadata && typeof metadata === 'object' ? metadata : undefined;\n  }\n\n  return contextOrMetadata;\n}\n\nfunction getClassDecoratorMetadata(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): DecoratorMetadataStore | undefined {\n  const metadataFromContext = getDecoratorMetadata(decoratorContext);\n  if (metadataFromContext) {\n    return metadataFromContext;\n  }\n\n  const metadataSymbol = (Symbol as typeof Symbol & { metadata?: symbol })\n    .metadata;\n  if (!metadataSymbol) {\n    return undefined;\n  }\n\n  const metadata = (target as unknown as Record<PropertyKey, unknown>)[\n    metadataSymbol\n  ];\n  return metadata && typeof metadata === 'object'\n    ? (metadata as DecoratorMetadataStore)\n    : undefined;\n}\n\nfunction queuePendingFieldDecorator(\n  metadata: DecoratorMetadataStore,\n  register: (ctor: Function) => void,\n): void {\n  const pendingDecorators =\n    (metadata[PENDING_FIELD_DECORATORS_KEY] as\n      | PendingDecoratorRegistration[]\n      | undefined) ?? [];\n\n  pendingDecorators.push({ register });\n  metadata[PENDING_FIELD_DECORATORS_KEY] = pendingDecorators;\n}\n\nexport function resolveDecoratorClassName(target: unknown): string | undefined {\n  if (typeof target === 'function') {\n    return target.name;\n  }\n\n  if (target && typeof target === 'object') {\n    return (target as LegacyPropertyDecoratorTarget).constructor?.name;\n  }\n\n  return undefined;\n}\n\nexport function applyPendingDecoratorRegistrations(\n  target: Function,\n  decoratorContext?: ClassDecoratorContext,\n): void {\n  const metadata = getClassDecoratorMetadata(target, decoratorContext);\n  if (!metadata) {\n    return;\n  }\n\n  const pendingDecorators = metadata[PENDING_FIELD_DECORATORS_KEY] as\n    | PendingDecoratorRegistration[]\n    | undefined;\n  if (!pendingDecorators || pendingDecorators.length === 0) {\n    return;\n  }\n\n  for (const { register } of pendingDecorators) {\n    if (!markStandardDecoratorRegistration(target, register)) {\n      continue;\n    }\n\n    register(target);\n  }\n\n  Reflect.deleteProperty(metadata, PENDING_FIELD_DECORATORS_KEY);\n}\n\n/**\n * Register a method decorator's metadata under the decorated class's name,\n * under whichever decorator implementation is running.\n *\n * The class-field twin below is the model, but the two cannot share one\n * function: their legacy signatures differ (a method decorator receives a\n * property descriptor as a third argument), and a static method's legacy\n * `target` is the CONSTRUCTOR while an instance method's is the prototype —\n * `getDecoratorConstructor` already handles both, which is why the receiver\n * resolution is shared even though the entry point is not.\n *\n * Registration is keyed by the CONSTRUCTOR, not by its name: two packages may\n * legitimately declare a class with the same simple name (`Account` exists in\n * both `smrt-ledgers` and `smrt-messages`), and the kernel forbids inferring\n * ownership from simple names. A name-keyed store would let one package's\n * `@method({ expose: false })` withhold the other's identically-named action.\n *\n * Metadata-only: nothing is wrapped and nothing is returned, so the decorated\n * method keeps its identity and remains directly callable (#2686).\n */\nexport function registerCompatibleMethodDecorator<\n  This,\n  Value extends AnyMethodOf<This>,\n>(\n  targetOrValue: LegacyPropertyDecoratorTarget | Value | undefined,\n  propertyKeyOrContext: CompatibleMethodDecoratorContext<This, Value>,\n  registerMethodDecorator: (\n    ctor: Function,\n    methodName: string,\n    isStatic: boolean,\n  ) => void,\n): void {\n  if (\n    typeof propertyKeyOrContext === 'string' ||\n    typeof propertyKeyOrContext === 'symbol'\n  ) {\n    // Legacy decorators hand a STATIC method its constructor and an instance\n    // method its prototype. That distinction IS the method's receiver, and\n    // nothing downstream can recover it in an unscanned runtime, so capture it\n    // here (#2686).\n    const ctor = getDecoratorConstructor(targetOrValue);\n    if (ctor) {\n      registerMethodDecorator(\n        ctor,\n        String(propertyKeyOrContext),\n        typeof targetOrValue === 'function',\n      );\n    }\n    return;\n  }\n\n  const context = propertyKeyOrContext;\n  const methodName = String(context.name);\n  // Standard decorators state the receiver outright.\n  const isStatic = context.static === true;\n  const register = (ctor: Function) =>\n    registerMethodDecorator(ctor, methodName, isStatic);\n  const metadata = getDecoratorMetadata(context);\n\n  if (metadata) {\n    queuePendingFieldDecorator(metadata, register);\n    return;\n  }\n\n  context.addInitializer?.(function registerSmrtMethodDecorator(this: unknown) {\n    // A static method's initializer runs with the constructor as `this`; an\n    // instance method's runs with the instance. `getDecoratorConstructor`\n    // reads the constructor in the latter case, so both land on the same class.\n    if (!markStandardDecoratorRegistration(this, register)) {\n      return;\n    }\n\n    const ctor = getDecoratorConstructor(this);\n    if (ctor) {\n      register(ctor);\n    }\n  });\n}\n\nexport function registerCompatibleFieldDecorator<This, Value>(\n  targetOrValue: LegacyPropertyDecoratorTarget | undefined,\n  propertyKeyOrContext: CompatiblePropertyDecoratorContext<This, Value>,\n  registerFieldDecorator: (className: string, propertyKey: string) => void,\n): void {\n  if (\n    typeof propertyKeyOrContext === 'string' ||\n    typeof propertyKeyOrContext === 'symbol'\n  ) {\n    const className = resolveDecoratorClassName(targetOrValue);\n    if (className) {\n      registerFieldDecorator(className, String(propertyKeyOrContext));\n    }\n    return;\n  }\n\n  const context = propertyKeyOrContext;\n  const propertyKey = String(context.name);\n  // The shared queue passes the CONSTRUCTOR (the method arm needs an identity a\n  // simple name cannot provide); field registration keeps its name-keyed store,\n  // so it derives the name here.\n  const register = (ctor: Function) => {\n    if (ctor.name) registerFieldDecorator(ctor.name, propertyKey);\n  };\n  const metadata = getDecoratorMetadata(context);\n\n  if (metadata) {\n    queuePendingFieldDecorator(metadata, register);\n    return;\n  }\n\n  context.addInitializer?.(function registerSmrtDecorator() {\n    if (!markStandardDecoratorRegistration(this, register)) {\n      return;\n    }\n\n    const ctor = getDecoratorConstructor(this);\n    if (ctor) {\n      register(ctor);\n    }\n  });\n}\n"],"mappings":"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"}

package/dist/decorators/index.d.ts

@@ -1,6 +1,8 @@
+import { CustomActionScope, ToolEffect } from '../generators/custom-action.js';
+import { ApiHttpMethod } from '../registry/types.js';
 import { FieldUIHints } from '../scanner/types.js';
 import { SQLDataType } from '../schema/types.js';
-import { CompatiblePropertyDecorator } from './compatibility.js';
+import { CompatibleMethodDecorator, CompatiblePropertyDecorator } from './compatibility.js';
 export type { FieldUIHints } from '../scanner/types.js';
 /**
  * Meta type wrapper for STI (Single Table Inheritance) meta fields
@@ -513,4 +515,120 @@ export declare function manyToMany(relatedClass: string | Function, options?: Om
  * @see {@link field} for regular (non-STI) field declarations
  */
 export declare function meta(options?: FieldOptions): CompatiblePropertyDecorator;
+/**
+ * Options for {@link method}.
+ *
+ * Every option is optional, and an omitted one falls back to the class-level
+ * `api.routes[methodName]` entry (or `ai.descriptions[methodName]` for
+ * `description`) when one exists. The merge is FIELD BY FIELD, so adding
+ * `@method({ description })` to a class that already declares a route verb and
+ * path does not reset them (#2686).
+ */
+export interface MethodOptions {
+    /**
+     * Override the default routing decision.
+     *
+     * Public methods are routed by default when they are WIRE-ABLE: every
+     * parameter can be built from a JSON request body or query string. Set
+     * `false` to withhold a method the heuristic accepted, `true` to expose one
+     * it rejected.
+     *
+     * `true` bypasses the heuristic and NOTHING else. It cannot manufacture a
+     * receiver, undo `api: false`, cross an `include`/`exclude` boundary, reach a
+     * non-public method, claim a CRUD verb, or hydrate a value the transport
+     * cannot build — a model-instance parameter still arrives as whatever JSON
+     * the caller sent.
+     */
+    expose?: boolean;
+    /**
+     * Why the method is withheld. Recorded in the knowledge artifact so
+     * `smrt doctor` and agents read an explanation instead of silence.
+     */
+    reason?: string;
+    /**
+     * HTTP verb for the generated route. Defaults to `POST`.
+     *
+     * Named `httpMethod`, not `method`: RFC 9110 calls this the request
+     * "method", so the protocol word is exactly the one that collides with the
+     * decorator's own name, and `@method({ method: 'POST' })` stutters.
+     * `httpMethod` is also already this framework's name for it — `ApiHttpMethod`
+     * is carried across the whole discovery/invoke path.
+     *
+     * Migrates from `api.routes[methodName].method`.
+     */
+    httpMethod?: ApiHttpMethod;
+    /**
+     * Route path segment(s), used verbatim and split on `/`.
+     * Defaults to the method name. Migrates from `api.routes[methodName].path`.
+     */
+    path?: string;
+    /**
+     * Declared receiver scope. Migrates from `api.routes[methodName].scope`.
+     *
+     * A DECLARATION checked against the method's executable receiver, not a
+     * relocation: an instance method is item-scoped and a static (or
+     * collection-class) method is collection-scoped, and no config can change
+     * that. A contradicting value is reported at build time and ignored.
+     */
+    scope?: CustomActionScope;
+    /**
+     * Agent-visible effect classification. Omitted actions are treated as
+     * `destructive`, so missing metadata can never widen browser capability
+     * exposure. Migrates from `api.routes[methodName].effect`.
+     */
+    effect?: ToolEffect;
+    /** Whether repeating the action with the same arguments is safe. */
+    idempotent?: boolean;
+    /** Whether the action may interact outside the SMRT application. */
+    openWorld?: boolean;
+    /**
+     * Description used by AI/tool surfaces, overriding the method's JSDoc.
+     * Migrates from `ai.descriptions[methodName]`.
+     */
+    description?: string;
+}
+/**
+ * Refines how a method is exposed on generated surfaces.
+ *
+ * The method counterpart of {@link field}, and symmetric with it: a manifest
+ * records exactly two collections per object, `fields` and `methods`. Neither
+ * decorator DECLARES its member — a property is a field because it is a
+ * property, and a method is a candidate action because it is public — both
+ * REFINE what the framework already inferred. `@field()` refines an inferred
+ * column type and constraints; `@method()` refines inferred exposure, its
+ * route shape, and its tool semantics.
+ *
+ * The name is `@method()` rather than `@action()` because of the negative
+ * case: withholding a method has to read correctly, and
+ * `@action({ expose: false })` contradicts itself — declaring something an
+ * action in order to say it is not one. "Action" keeps its established meaning
+ * in the generators (a non-CRUD method exposed on a surface); this decorator
+ * is how a method BECOMES one.
+ *
+ * Metadata only: the decorated method is not wrapped and keeps its identity,
+ * so it stays directly callable.
+ *
+ * @example Shape the generated route
+ * ```typescript
+ * @method({ httpMethod: 'POST', path: 'reviews', effect: 'write' })
+ * async runReview(options?: RunContentReviewOptions) { … }
+ * ```
+ *
+ * @example Withhold a method the heuristic would have routed
+ * ```typescript
+ * @method({ expose: false, reason: 'callback registration, not a wire operation' })
+ * static registerValidator(validator: ValidatorFunction) { … }
+ * ```
+ *
+ * @example Force a route the heuristic rejected
+ * ```typescript
+ * // `expose: true` bypasses the heuristic only — this method must still
+ * // accept whatever JSON the caller sends for `asset`.
+ * @method({ expose: true })
+ * async addAsset(asset: Asset) { … }
+ * ```
+ *
+ * @see {@link field} for the property-side refinement decorator
+ */
+export declare function method(options?: MethodOptions): CompatibleMethodDecorator;
 //# sourceMappingURL=index.d.ts.map

package/dist/decorators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/decorators/index.ts"],"names":[],"mappings":"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"}

package/dist/decorators/index.js

@@ -1,13 +1,7 @@
-import { registerCompatibleFieldDecorator } from "./compatibility.js";
+import { registerCompatibleFieldDecorator, registerCompatibleMethodDecorator } from "./compatibility.js";
 import { ObjectRegistry } from "../registry.js";
 //#region src/decorators/index.ts
 /**
-* Field decorators for SMRT objects
-*
-* Modern decorator-based API for defining SMRT object properties.
-* Properties are typed as primitives with decorator metadata.
-*/
-/**
 * Resolve a relationship decorator's target argument to a class name.
 *
 * Accepted target forms:
@@ -407,7 +401,57 @@ function meta(options = {}) {
 		});
 	});
 }
+/**
+* Refines how a method is exposed on generated surfaces.
+*
+* The method counterpart of {@link field}, and symmetric with it: a manifest
+* records exactly two collections per object, `fields` and `methods`. Neither
+* decorator DECLARES its member — a property is a field because it is a
+* property, and a method is a candidate action because it is public — both
+* REFINE what the framework already inferred. `@field()` refines an inferred
+* column type and constraints; `@method()` refines inferred exposure, its
+* route shape, and its tool semantics.
+*
+* The name is `@method()` rather than `@action()` because of the negative
+* case: withholding a method has to read correctly, and
+* `@action({ expose: false })` contradicts itself — declaring something an
+* action in order to say it is not one. "Action" keeps its established meaning
+* in the generators (a non-CRUD method exposed on a surface); this decorator
+* is how a method BECOMES one.
+*
+* Metadata only: the decorated method is not wrapped and keeps its identity,
+* so it stays directly callable.
+*
+* @example Shape the generated route
+* ```typescript
+* @method({ httpMethod: 'POST', path: 'reviews', effect: 'write' })
+* async runReview(options?: RunContentReviewOptions) { … }
+* ```
+*
+* @example Withhold a method the heuristic would have routed
+* ```typescript
+* @method({ expose: false, reason: 'callback registration, not a wire operation' })
+* static registerValidator(validator: ValidatorFunction) { … }
+* ```
+*
+* @example Force a route the heuristic rejected
+* ```typescript
+* // `expose: true` bypasses the heuristic only — this method must still
+* // accept whatever JSON the caller sends for `asset`.
+* @method({ expose: true })
+* async addAsset(asset: Asset) { … }
+* ```
+*
+* @see {@link field} for the property-side refinement decorator
+*/
+function method(options = {}) {
+	return ((targetOrValue, propertyKeyOrContext) => {
+		registerCompatibleMethodDecorator(targetOrValue, propertyKeyOrContext, (ctor, methodName, isStatic) => {
+			ObjectRegistry.registerMethodDecorator(ctor, methodName, options, isStatic);
+		});
+	});
+}
 //#endregion
-export { crossPackageRef, field, foreignKey, manyToMany, meta, oneToMany };
+export { crossPackageRef, field, foreignKey, manyToMany, meta, method, oneToMany };
 
 //# sourceMappingURL=index.js.map