@suss/packs 0.33.0 → 0.34.0

package/dist/aws-sqs.js

@@ -1,7 +1,11 @@
 // ../framework/aws-sqs/dist/index.js
 import { Node as N } from "ts-morph";
 import { z } from "zod";
-import { climbSyntax, readConfiguredCall } from "@suss/adapter-typescript";
+import {
+  climbSyntax,
+  readConfiguredCall,
+  receiverTypesOf
+} from "@suss/adapter-typescript";
 import { messageBusBinding } from "@suss/behavioral-ir";
 import { configuredCallOption } from "@suss/extractor";
 import { constructedFrom, messageSends, pack } from "@suss/recognize";
@@ -35,7 +39,7 @@ function sendDeclarations() {
       wire: "aws_sqs",
       client: constructedFrom(SQS),
       messages: { each: "in", property: "Entries" },
-      // A batch states the queue once beside the list of messages.
+      // The queue is on the command input, once, beside the list of messages.
       channel: [{ property: ["QueueUrl"], on: "theInput" }],
       body: "MessageBody"
     }).methods(INSIDE_THE_COMMAND(["SendMessageBatchCommand"])).example(
@@ -72,16 +76,15 @@ function messageReceiveRecognizer(call, ctx) {
   if (!N.isIdentifier(recordExpr)) {
     return null;
   }
-  if (!isSqsRecordIdentifier(recordExpr)) {
+  if (!isSqsRecordIdentifier(recordExpr) && !isTypedSqsRecord(recordExpr)) {
     return null;
   }
   const fields = extractDestructuredFields(callNode);
   return [
     {
       type: "interaction",
-      // Channel intentionally null: the queue a handler drains is
-      // stated by the CFN event-source mapping, so this side does not
-      // name it and the pairing pass joins by codeScope instead.
+      // The CloudFormation event source mapping sets the queue, so the
+      // pairing pass joins this effect to its consumer by code scope.
       binding: messageBusBinding({
         recognition: "@suss/framework-aws-sqs",
         messageBus: "aws_sqs",
@@ -122,6 +125,12 @@ function isSqsRecordIdentifier(recordExpr) {
   }
   return false;
 }
+function isTypedSqsRecord(recordExpr) {
+  return receiverTypesOf(recordExpr).some((type) => isLambdaSqsRecord(type));
+}
+function isLambdaSqsRecord(type) {
+  return type.name === "SQSRecord" && type.declaredIn.some((filePath) => filePath.includes("/aws-lambda/"));
+}
 function extractDestructuredFields(call) {
   const parent = climbSyntax(call).getParent();
   if (parent === void 0 || !N.isVariableDeclaration(parent)) {
@@ -153,8 +162,8 @@ function extractDestructuredFields(call) {
 }
 var optionsSchema = z.object({
   /**
-   * Dispatchers this project sends through. Each one adds a
-   * recognizer and widens the import gate to the module it points at.
+   * Each dispatcher adds a recognizer, and the pack also reads files
+   * that import the dispatcher's module.
    */
   producers: z.array(configuredCallOption).optional()
 }).strict();
@@ -191,8 +200,8 @@ function sqsFramework(options = {}) {
     languages: ["typescript", "javascript"],
     recognizedAs: "@suss/framework-aws-sqs",
     protocol: "sqs",
-    // The consumer side reads SQSEvent handlers, whose files import
-    // aws-lambda rather than the SQS client.
+    // A handler file imports `SQSEvent` from aws-lambda and often never
+    // imports the SQS client.
     requiresImport: ["aws-lambda", ...producers.map((p) => p.module)],
     recognizers: [
       messageReceiveRecognizer,
@@ -204,7 +213,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-sqs",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-sqs" }],
-  reads: "AWS SDK v3 SQS producer calls, emits message-send interactions."
+  reads: "AWS SDK v3 SQS producer calls. Each one becomes a message-send interaction."
 };
 var index_default = sqsFramework;
 export {

package/dist/aws-ssm.js

@@ -29,7 +29,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-aws-ssm",
   dependencies: [{ ecosystem: "npm", name: "@aws-sdk/client-ssm" }],
-  reads: "AWS SSM Parameter Store calls, emits storage-access interactions against the parameter."
+  reads: "AWS SSM Parameter Store calls. Each one becomes a storage-access interaction on the parameter."
 };
 var index_default = ssmFramework;
 export {

package/dist/axios.js

@@ -17,23 +17,18 @@ var clientFactory = z.object({
 }).strict();
 var optionsSchema = z.object({
   /**
-   * Project functions this project builds axios instances through,
-   * beyond the built-in axios.create. Each site importing one of
-   * these and calling it is a client instance the same way an
-   * axios.create() result is, wherever the call it delegates to
-   * lives.
+   * Project functions that build axios instances, in addition to
+   * axios.create. Calling one of these gives a client instance, the
+   * same as an axios.create() result.
    */
   factories: z.array(clientFactory).optional()
 }).strict();
 function discoveryForVerb(verb, factories) {
   const patterns = [
     {
-      // Matches both shapes:
-      //   axios.<verb>("/path", ...)
-      //   const api = axios.create({ ... }); api.<verb>("/path", ...)
-      // The factoryMethods entry tells the adapter that variables initialized
-      // from axios.create(...) are also clients, wherever that call and
-      // this one turn out to live.
+      // Matches `axios.<verb>(path)` and `api.<verb>(path)`. factoryMethods
+      // makes a variable set from axios.create(...) a client too, even
+      // when it is created in another file.
       kind: "client",
       match: {
         type: "clientCall",
@@ -64,18 +59,9 @@ function discoveryForVerb(verb, factories) {
         method: { type: "literal", value: verb.toUpperCase() },
         path: { type: "fromArgument", position: 0 }
       },
-      // A bare specifier gates the way "axios" above does: cheap and
-      // exact, since two files spelling a package name the same way
-      // mean the same package. A path-shaped module ("./apiClient")
-      // points at a location relative to wherever it's written, and the
-      // pre-filter only ever reads a file's own import text before
-      // anything is parsed, so it has no way to tell "./apiClient"
-      // and a consumer's "../apiClient" apart from string text alone.
-      // Narrowing on that string would exclude the consumer roughly
-      // as often as include it, so a path-shaped factory gives no
-      // gate at all and every file is walked; the discovery layer
-      // resolves the module correctly once it's reading a file's
-      // imports against a parsed project.
+      // Each importing file spells a relative path differently, so the
+      // import-text prefilter cannot match one and a path-shaped factory
+      // walks every file. The README has the details.
       requiresImport: isPathShapedSpecifier(factory.module) ? [] : [factory.module]
     });
   }
@@ -153,13 +139,13 @@ function axiosPack(options = {}) {
       params: []
     },
     responseSemantics: [
-      // axios returns AxiosResponse: body lives on .data, not .body or .json()
+      // axios puts the parsed response body on `.data`.
       { name: "data", access: "property", semantics: { type: "body" } },
       { name: "status", access: "property", semantics: { type: "statusCode" } },
       { name: "headers", access: "property", semantics: { type: "headers" } }
     ],
-    // A non-2xx rejects, so the caller never gets a response to read a
-    // status off, and its catch is where every failure arrives.
+    // axios rejects on a non-2xx status, so every failure reaches the
+    // caller's catch block instead of coming back as a response.
     failureDelivery: "exception"
   };
 }
@@ -167,7 +153,7 @@ var declares = {
   kind: "client",
   package: "@suss/client-axios",
   dependencies: [{ ecosystem: "npm", name: "axios" }],
-  reads: "axios call sites + `axios.create` factories."
+  reads: "axios call sites, including calls on a client that `axios.create` made."
 };
 var index_default = axiosPack;
 export {

package/dist/bigquery-python.js

@@ -88,8 +88,8 @@ function bigqueryClients() {
       clientTypes: ["BigQueryHook"],
       statements: HOOK_STATEMENTS,
       tables: HOOK_TABLES,
-      // The hook documents `get_client` as handing back the client
-      // library's own `Client`, so a chain off it reads as one.
+      // The hook documents `get_client` as returning the client library's
+      // own `Client`, so a chain off it is read the same way.
       handsBack: [
         { method: "get_client", module: CLIENT_MODULE, name: "Client" }
       ],
@@ -113,7 +113,7 @@ var declares = {
     { ecosystem: "pypi", name: "google-cloud-bigquery" },
     { ecosystem: "pypi", name: "apache-airflow-providers-google" }
   ],
-  reads: "BigQuery calls (Python): the statement a client or an Airflow hook is handed, read for the tables it touches, and the calls that say which table without writing SQL."
+  reads: "BigQuery calls (Python). The statement a client or an Airflow hook is handed is read for the tables it touches. Calls such as `get_table` and `insert_rows` take a table name instead of SQL, and that name is read too."
 };
 var index_default = bigqueryFramework;
 export {

package/dist/bigquery.js

@@ -45,7 +45,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-bigquery",
   dependencies: [{ ecosystem: "npm", name: "@google-cloud/bigquery" }],
-  reads: "BigQuery queries and table calls, emits storage-access interactions with the dataset as the scope."
+  reads: "BigQuery queries and table calls. Each one becomes a storage-access interaction scoped to its dataset."
 };
 var index_default = bigqueryFramework;
 export {

package/dist/{chunk-NYWZHQBJ.js → chunk-GK4BILHB.js}

@@ -3,9 +3,8 @@ import { z } from "zod";
 import { storageSystemOption } from "@suss/extractor";
 var optionsSchema = z.object({
   /**
-   * Which database is behind the connection. SQLAlchemy talks to all of
-   * them and the URL says which, so this is the project's own choice
-   * rather than something the library settles.
+   * Which database is behind the engine. SQLAlchemy works with several,
+   * and the connection URL picks one, so the project has to set this.
    */
   storageSystem: storageSystemOption
 }).strict();
@@ -26,8 +25,8 @@ function sqlalchemyStorage(options) {
         "bulk_insert_mappings",
         "bulk_update_mappings"
       ],
-      // A Session runs a statement built by `select`/`update`/... whose
-      // own chain is read, and the rest of these manage the session.
+      // `execute` and the scalar calls run a statement whose own chain is
+      // read already, and the rest only manage the session.
       recordsNothing: [
         "execute",
         "scalars",
@@ -46,9 +45,9 @@ function sqlalchemyStorage(options) {
       module: "sqlalchemy",
       queryTypes: ["Select", "Update", "Delete", "Insert"],
       writes: ["update", "delete", "insert", "commit"],
-      // 2.0 style writes `select(User.id).where(...)`, importing the
-      // constructor rather than reaching it through a mapped class, so there
-      // is no project method in between whose return says what it is.
+      // A 2.0 statement such as `select(User.id).where(...)` calls an
+      // imported constructor directly, so there is no project method in
+      // the chain whose return type the adapter could read.
       queryFunctions: ["select", "insert", "update", "delete"],
       valueMethods: ["values"],
       storageSystem: options.storageSystem
@@ -129,7 +128,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-sqlalchemy",
   dependencies: [{ ecosystem: "pypi", name: "sqlalchemy" }],
-  reads: `SQLAlchemy calls (Python): says which types a query comes back as and which methods write, and the adapter matches a call chain by resolving through a project's own base class to what the method behind it says it returns.`,
+  reads: `SQLAlchemy calls (Python). The pack declares which types a query returns and which methods write. The adapter matches a call chain by following a project's own base class to the method behind the call, and reads that method's declared return type.`,
   configuration: {
     file: "suss.sqlalchemy.json",
     example: { storageSystem: "postgresql" },

package/dist/cloudflare-workers.js

@@ -15,7 +15,11 @@ import {
 } from "@suss/adapter-typescript";
 import { runtimeConfigBinding } from "@suss/behavioral-ir";
 import { Node as N3 } from "ts-morph";
-import { readName as readName2, stringValueOf } from "@suss/adapter-typescript";
+import {
+  readName as readName2,
+  receiverTypesOf,
+  stringValueOf
+} from "@suss/adapter-typescript";
 import { storageBinding } from "@suss/behavioral-ir";
 import { readSqlAccess } from "@suss/sql";
 var TRIGGERS = {
@@ -163,11 +167,10 @@ function listenerAt(node) {
 var ENV_PARAMETER_POSITION = 1;
 var readName = (name) => `env.${name}`;
 function envBindingRecognizer(options = {}) {
-  const instanceName = options.scriptName ?? "<unknown>";
   return (access, ctx) => {
     const { resolution } = ctx;
     const read = envReadAt(access, resolution);
-    return read === null ? null : [configReadEffect(read, instanceName)];
+    return read === null ? null : [configReadEffect(read, options.scriptName)];
   };
 }
 function envReadAt(node, resolution) {
@@ -222,7 +225,7 @@ function configReadEffect(read, instanceName) {
     binding: runtimeConfigBinding({
       recognition: "@suss/framework-cloudflare-workers",
       deploymentTarget: "worker",
-      instanceName
+      ...instanceName === void 0 ? {} : { instanceName }
     }),
     callee: readName(read.name),
     interaction: {
@@ -297,10 +300,7 @@ function storeBindingRecognizer(call, ctx) {
   if (binding === null) {
     return null;
   }
-  const store = STORES[binding.typeName];
-  if (store === void 0) {
-    return null;
-  }
+  const { store } = binding;
   const method = callee.getName();
   const access = store.read(method, callNode, reading);
   if (access === null) {
@@ -320,8 +320,8 @@ function storeBindingRecognizer(call, ctx) {
       interaction: {
         class: "storage-access",
         kind: access.kind,
-        // KV and R2 keep opaque values and a D1 statement is judged at
-        // database level, so no call states a field.
+        // KV and R2 values are opaque, and a D1 statement is read at the
+        // database level, so a call never records a field.
         fields: [],
         operation: method,
         ...access.selector !== void 0 ? { selector: [access.selector] } : {}
@@ -344,11 +344,16 @@ function boundReceiver(subject, reading) {
   if (!N3.isIdentifier(env) || !isTriggerEnvArgument(env, reading.resolution)) {
     return null;
   }
-  const typeName = declaredTypeName(receiver);
-  if (typeName === null) {
-    return null;
+  const store = storeTypedOn(receiver);
+  return store === null ? null : { name: receiver.getName(), store };
+}
+function storeTypedOn(receiver) {
+  for (const type of receiverTypesOf(receiver)) {
+    if (Object.hasOwn(STORES, type.name)) {
+      return STORES[type.name];
+    }
   }
-  return { name: receiver.getName(), typeName };
+  return null;
 }
 function declaredInitializer(identifier) {
   for (const declaration of identifier.getSymbol()?.getDeclarations() ?? []) {
@@ -358,25 +363,11 @@ function declaredInitializer(identifier) {
   }
   return null;
 }
-function declaredTypeName(receiver) {
-  const declarations = receiver.getNameNode().getSymbol()?.getDeclarations() ?? [];
-  for (const declaration of declarations) {
-    if (!N3.isPropertySignature(declaration)) {
-      continue;
-    }
-    const typeNode = declaration.getTypeNode();
-    if (typeNode !== void 0) {
-      return typeNode.getText();
-    }
-  }
-  return null;
-}
 var optionsSchema = z.object({
   /**
-   * The name the deployment gives this Worker, which is `name` in
-   * `wrangler.toml`. Supplying it stamps every unit with the deployable
-   * it runs as, so a runtime-config provider pairs by unit instead of by
-   * directory. Left out, the directory decides.
+   * The Worker's `name` from `wrangler.toml`. When it is set, every unit
+   * records it as its deployable, so a runtime-config provider pairs
+   * with the Worker by name. Without it, units pair by directory.
    */
   scriptName: z.string().optional()
 }).strict();
@@ -385,14 +376,14 @@ function cloudflareWorkersFramework(options = {}) {
     name: "cloudflare-workers",
     protocol: "http",
     languages: ["typescript", "javascript"],
-    // Nothing is registered in code, so there is no data-driven
-    // discovery to declare.
+    // A Worker registers nothing in code, so the pattern list stays empty
+    // and the callback reads the exported object.
     discovery: [],
     discoverUnits: cloudflareWorkersDiscovery(options),
     terminals: [
       {
-        // new Response(body, { status }), which is what a Worker returns
-        // for everything: JSON, a redirect, a stream, plain text.
+        // new Response(body, { status }). A Worker returns a Response for
+        // JSON, a redirect, a stream and plain text alike.
         kind: "response",
         match: { type: "functionCall", functionName: "Response" },
         extraction: {

package/dist/drizzle.js

@@ -7,6 +7,7 @@ import {
   propertiesOf,
   propertyNameOf,
   propertyOf,
+  receiverTypesOf,
   stringValueOf,
   writtenNodeOf
 } from "@suss/adapter-typescript";
@@ -25,12 +26,12 @@ var DRIZZLE_PACKAGE = "drizzle-orm";
 var CHAIN_WALK_LIMIT = 12;
 var optionsSchema = z.object({
   /**
-   * Storage system the recognized calls target. Must match the
-   * `storageSystem` on provider summaries for pairing keys to line
-   * up. Defaults to `"postgresql"`, the dominant Drizzle deployment.
+   * The storage system the calls target, `"postgresql"` when unset. It
+   * has to match the `storageSystem` on provider summaries, or the
+   * calls do not pair.
    */
   storageSystem: storageSystemOption.optional(),
-  /** Scope label for the storage binding. Defaults to `"default"`. */
+  /** Scope for the storage binding, `"default"` when unset. */
   scope: scopeOption.optional()
 }).strict();
 function rawStatements(opts) {
@@ -159,7 +160,7 @@ function recognizeQueryApi(call, receiver, operation, resolution) {
   if (!isDrizzleReceiver(queryAccess.getExpression())) {
     return null;
   }
-  const table = resolveTableName(receiver, resolution) ?? receiver.getName();
+  const table = resolveTableName(receiver, resolution);
   const optionsArg = call.getArguments()[0];
   const options = optionsArg === void 0 ? null : objectLiteralOf(optionsArg, resolution);
   const fields = [];
@@ -200,17 +201,12 @@ function collectChainCalls(anchor) {
   return chain;
 }
 function isDrizzleReceiver(node) {
-  const type = node.getType();
-  const symbol = type.getSymbol() ?? type.getAliasSymbol();
-  if (symbol === void 0) {
-    return false;
-  }
-  for (const decl of symbol.getDeclarations()) {
-    if (decl.getSourceFile().getFilePath().includes("/drizzle-orm/")) {
-      return true;
-    }
-  }
-  return false;
+  return receiverTypesOf(node).some((type) => declaredByDrizzle(type));
+}
+function declaredByDrizzle(type) {
+  return type.declaredIn.some(
+    (filePath) => filePath.includes(`/${DRIZZLE_PACKAGE}/`)
+  );
 }
 function resolveTableName(tableExpr, resolution) {
   const written = writtenNodeOf(tableExpr, resolution);
@@ -293,9 +289,8 @@ function drizzleFramework(options = {}) {
     discovery: [],
     terminals: [],
     inputMapping: { type: "positionalParams", params: [] },
-    // Gate on drizzle-orm imports (matches subpaths like
-    // drizzle-orm/pg-core and driver entry points): files without
-    // them can't type-check as Drizzle receivers anyway.
+    // A file with no `drizzle-orm` import, subpaths included, has no
+    // value whose type Drizzle declares.
     requiresImport: ["drizzle-orm"],
     invocationRecognizers: [makeRecognizer(options)],
     // A statement can be written as a tagged template, which the
@@ -308,7 +303,7 @@ var declares = {
   kind: "effects",
   package: "@suss/framework-drizzle",
   dependencies: [{ ecosystem: "npm", name: "drizzle-orm" }],
-  reads: "Drizzle ORM query-builder and relational-query calls, emits storage-access interactions with SQL table names."
+  reads: "Drizzle ORM query-builder and relational-query calls. Each one becomes a storage-access interaction on the SQL table it touches."
 };
 var index_default = drizzleFramework;
 export {

package/dist/express.js

@@ -43,12 +43,9 @@ function expressFramework(_options = {}) {
     name: "express",
     protocol: "http",
     languages: ["typescript", "javascript"],
-    // Express exposes the routable via either `Router()` (named) or
-    // `express()` (default). Both drive handler registration the same
-    // way; `httpRouteDiscovery` emits one DiscoveryPattern per name.
-    // Either can also be mounted onto another with `app.use(prefix,
-    // router)`, so a route declared on the mounted router summarizes
-    // with the mount's prefix composed in.
+    // Routes go on `Router()` or on `express()`, and either can be mounted
+    // with `app.use(prefix, router)`. A route on a mounted router is
+    // summarized with the mount's prefix in front of its path.
     discovery: [
       ...httpRouteDiscovery({
         importModule: "express",

package/dist/fabrication.d.ts

@@ -0,0 +1 @@
+export { declares, default, optionsSchema } from '@suss/framework-fabrication';

package/dist/fabrication.js

@@ -0,0 +1,36 @@
+// ../framework/fabrication/dist/index.js
+import { z } from "zod";
+var optionsSchema = z.object({}).strict();
+var LIBRARY = "Fabricate";
+function fabricationFramework(_options = {}) {
+  return {
+    name: "fabrication",
+    protocol: "in-process",
+    discovery: [],
+    factories: [
+      {
+        definitionMethods: ["Fabricator"],
+        classKeywords: ["class_name"],
+        parentKeywords: ["from"],
+        nestedDefinitionsInherit: false,
+        builders: [
+          { method: "Fabricate" },
+          { method: "build", receiver: LIBRARY },
+          { method: "create", receiver: LIBRARY }
+        ]
+      }
+    ]
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-fabrication",
+  dependencies: [],
+  reads: "Fabrication builds in tests (Ruby), typed by the class each fabricator builds, so a test's calls on them are followed."
+};
+var index_default = fabricationFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};

package/dist/factory-bot.d.ts

@@ -0,0 +1 @@
+export { declares, default, optionsSchema } from '@suss/framework-factory-bot';

package/dist/factory-bot.js

@@ -0,0 +1,36 @@
+// ../framework/factory-bot/dist/index.js
+import { z } from "zod";
+var optionsSchema = z.object({}).strict();
+var BUILDS = ["create", "build", "build_stubbed"];
+var LIBRARY = "FactoryBot";
+function factoryBotFramework(_options = {}) {
+  return {
+    name: "factory-bot",
+    protocol: "in-process",
+    discovery: [],
+    factories: [
+      {
+        definitionMethods: ["factory"],
+        classKeywords: ["class"],
+        parentKeywords: ["parent"],
+        nestedDefinitionsInherit: true,
+        builders: [
+          ...BUILDS.map((method) => ({ method })),
+          ...BUILDS.map((method) => ({ method, receiver: LIBRARY }))
+        ]
+      }
+    ]
+  };
+}
+var declares = {
+  kind: "framework",
+  package: "@suss/framework-factory-bot",
+  dependencies: [],
+  reads: "factory_bot builds in tests (Ruby), typed by the class each factory builds, so a test's calls on them are followed."
+};
+var index_default = factoryBotFramework;
+export {
+  declares,
+  index_default as default,
+  optionsSchema
+};

package/dist/faraday.js

@@ -17,14 +17,13 @@ function faradayClient() {
       {
         constantName: "Faraday",
         verbMethodNames: VERB_METHODS,
-        // Every one of them takes the URL first.
         url: { position: 0 },
         receiverBuilders: ["new"],
-        // `Faraday.new(url: "https://api.example.com/v1")` serves every
-        // call on that connection under the path of its own URL.
+        // Calls on a connection from `Faraday.new(url: ".../v1")` get the
+        // path of that URL in front of their own.
         builderUrlKeyword: "url",
-        // What a caller reads off the response it got back. A test on
-        // one of these says which statuses the caller handles.
+        // A caller's condition on one of these members shows which
+        // statuses it handles.
         response: {
           statusCode: ["status"],
           success: ["success?"],

package/dist/fastapi.js

@@ -2,10 +2,9 @@
 import { z } from "zod";
 var optionsSchema = z.object({
   /**
-   * Modules a project's own wrapper re-exports FastAPI's constructors
-   * from. FastAPI's own module is always accepted. The wrapper's name
-   * is the project's own choice, so it is supplied by whoever
-   * configures the pack rather than hardcoded here.
+   * Modules that re-export FastAPI's constructors, on top of `fastapi`
+   * itself. A dependency stub fills this in; a project's config file
+   * may not set it.
    */
   wrapperModules: z.array(z.string()).optional()
 }).strict();
@@ -18,10 +17,25 @@ var VERB_ATTRIBUTE_NAMES = {
   head: "HEAD",
   options: "OPTIONS"
 };
+var PARAMETER_SOURCES = {
+  Header: { role: "headers", underscoresAs: "-" },
+  Query: { role: "queryParams" },
+  Path: { role: "pathParams" },
+  Body: { role: "requestBody" },
+  Form: { role: "requestBody" },
+  Cookie: { role: "cookies" }
+};
+var REQUEST_SPELLING = {
+  headers: { path: ["headers"], saysWhichField: true },
+  query: { path: ["queryParams"], saysWhichField: true },
+  params: { path: ["pathParams"], saysWhichField: true },
+  body: { path: ["requestBody"], saysWhichField: true }
+};
 function fastapiFramework(options = {}) {
   return {
     name: "fastapi",
     protocol: "http",
+    requestSpelling: REQUEST_SPELLING,
     ...options.wrapperModules !== void 0 ? { projectModules: options.wrapperModules } : {},
     discovery: [
       {
@@ -33,6 +47,8 @@ function fastapiFramework(options = {}) {
         // FastAPI resolves both of these itself and calls the handler with
         // the result, so a parameter defaulted to one is never sent.
         injectedParameterCallees: ["Depends", "Security"],
+        parameterSources: PARAMETER_SOURCES,
+        parameterAliasKeyword: "alias",
         // FastAPI returns 200 for a route that declares no status.
         defaultStatusCode: 200,
         responseModelKeyword: "response_model",
@@ -106,7 +122,7 @@ var declares = {
   kind: "framework",
   package: "@suss/framework-fastapi",
   dependencies: [{ ecosystem: "pypi", name: "fastapi" }],
-  reads: `FastAPI routes (Python): the verb comes from the decorator's own attribute name, \`APIRouter\` prefixes are composed one \`include_router\` hop deep, and \`response_model\` / \`status_code\` are taken as the declared contract.`
+  reads: `FastAPI routes (Python). The verb comes from the decorator's attribute name, \`APIRouter\` prefixes are composed one \`include_router\` hop deep, and \`response_model\` and \`status_code\` are taken as the declared contract.`
 };
 var index_default = fastapiFramework;
 export {