@starci/hfs 4.11.22 → 4.12.2

package/runtime/scripts/hfs/architecture/next-data-contract.mjs

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 import { canonical, exactKeys, isInside, slash } from './config.mjs';
-
 const CONTRACT_SCHEMA = 'starci/next-data-lifecycle@1';
 const SOURCE = /\.[cm]?[jt]sx?$/i;
 const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
@@ -12,93 +11,116 @@ const SWR_KEYS = new Set(['package', 'major']);
 const HOOK_KEYS = new Set(['id', 'path', 'export', 'kind', 'resultBinding', 'identities']);
 const IDENTITY_KEYS = new Set(['id', 'binding', 'gatesRequest', 'resource']);
 function relativeSource(repository, value, label) {
-  repository = path.resolve(repository);
-  if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value)) throw new Error(`${label} must be a non-empty repository-relative source path.`);
-  const relative = slash(value.trim()).replace(/^\.\//, '');
-  if (relative.split('/').includes('..') || !SOURCE.test(relative) || /\.d\.[cm]?[jt]s$/i.test(relative)) {
-    throw new Error(`${label} must be a production TypeScript or JavaScript source path.`);
-  }
-  const absolute = path.resolve(repository, ...relative.split('/'));
-  if (!isInside(repository, absolute)) throw new Error(`${label} must stay inside the repository.`);
-  for (let current = absolute; current !== repository; current = path.dirname(current)) {
-    const stat = fs.lstatSync(current);
-    if (stat.isSymbolicLink()) throw new Error(`${label} must not cross a symbolic-link or junction ancestor.`);
-  }
-  const stat = fs.lstatSync(absolute);
-  if (!stat.isFile() || !isInside(canonical(repository), canonical(absolute))) throw new Error(`${label} must be a regular source file inside the repository.`);
-  return relative;
+    repository = path.resolve(repository);
+    if (typeof value !== 'string' || !value.trim() || path.isAbsolute(value))
+        throw new Error(`${label} must be a non-empty repository-relative source path.`);
+    const relative = slash(value.trim()).replace(/^\.\//, '');
+    if (relative.split('/').includes('..') || !SOURCE.test(relative) || /\.d\.[cm]?[jt]s$/i.test(relative)) {
+        throw new Error(`${label} must be a production TypeScript or JavaScript source path.`);
+    }
+    const absolute = path.resolve(repository, ...relative.split('/'));
+    if (!isInside(repository, absolute))
+        throw new Error(`${label} must stay inside the repository.`);
+    for (let current = absolute; current !== repository; current = path.dirname(current)) {
+        const stat = fs.lstatSync(current);
+        if (stat.isSymbolicLink())
+            throw new Error(`${label} must not cross a symbolic-link or junction ancestor.`);
+    }
+    const stat = fs.lstatSync(absolute);
+    if (!stat.isFile() || !isInside(canonical(repository), canonical(absolute)))
+        throw new Error(`${label} must be a regular source file inside the repository.`);
+    return relative;
 }
-
 const CONTRACT_LABEL = 'package.json#starci.codePatterns.next.dataLifecycle';
-
 function parseSwr(swr) {
-  exactKeys(swr, SWR_KEYS, 'dataLifecycle.swr');
-  if (swr.package !== 'swr' || !Number.isInteger(swr.major) || swr.major < 1) {
-    throw new Error('dataLifecycle.swr must bind package swr and one positive integer major version.');
-  }
+    exactKeys(swr, SWR_KEYS, 'dataLifecycle.swr');
+    if (swr.package !== 'swr' || !Number.isInteger(swr.major) || swr.major < 1) {
+        throw new Error('dataLifecycle.swr must bind package swr and one positive integer major version.');
+    }
 }
-
 function parseIdentity(identity, identityLabel, seen) {
-  exactKeys(identity, IDENTITY_KEYS, identityLabel);
-  if (typeof identity.id !== 'string' || !identity.id.trim() || seen.ids.has(identity.id.trim())) throw new Error(`${identityLabel}.id must be unique and non-empty.`);
-  if (typeof identity.binding !== 'string' || !BINDING.test(identity.binding) || seen.bindings.has(identity.binding)) throw new Error(`${identityLabel}.binding must be a unique identifier or property path.`);
-  if (typeof identity.gatesRequest !== 'boolean' || typeof identity.resource !== 'boolean') throw new Error(`${identityLabel} must explicitly declare gatesRequest and resource booleans.`);
-  seen.ids.add(identity.id.trim());
-  seen.bindings.add(identity.binding);
-  return { id: identity.id.trim(), binding: identity.binding, gatesRequest: identity.gatesRequest, resource: identity.resource };
+    exactKeys(identity, IDENTITY_KEYS, identityLabel);
+    if (typeof identity.id !== 'string' || !identity.id.trim() || seen.ids.has(identity.id.trim()))
+        throw new Error(`${identityLabel}.id must be unique and non-empty.`);
+    if (typeof identity.binding !== 'string' || !BINDING.test(identity.binding) || seen.bindings.has(identity.binding))
+        throw new Error(`${identityLabel}.binding must be a unique identifier or property path.`);
+    if (typeof identity.gatesRequest !== 'boolean' || typeof identity.resource !== 'boolean')
+        throw new Error(`${identityLabel} must explicitly declare gatesRequest and resource booleans.`);
+    seen.ids.add(identity.id.trim());
+    seen.bindings.add(identity.binding);
+    return { id: identity.id.trim(), binding: identity.binding, gatesRequest: identity.gatesRequest, resource: identity.resource };
 }
-
 function parseHook(config, hook, label, ids) {
-  exactKeys(hook, HOOK_KEYS, label);
-  if (typeof hook.id !== 'string' || !hook.id.trim() || ids.has(hook.id.trim())) throw new Error(`${label}.id must be unique and non-empty.`);
-  ids.add(hook.id.trim());
-  const source = relativeSource(config.root, hook.path, `${label}.path`);
-  if (typeof hook.export !== 'string' || !/^use[A-Z0-9_$][\w$]*$/.test(hook.export)) throw new Error(`${label}.export must name one exported use* hook.`);
-  if (!['query', 'mutation'].includes(hook.kind)) throw new Error(`${label}.kind must be query or mutation.`);
-  if (hook.resultBinding !== undefined && (typeof hook.resultBinding !== 'string' || !IDENTIFIER.test(hook.resultBinding))) {
-    throw new Error(`${label}.resultBinding must be one local identifier.`);
-  }
-  if (!Array.isArray(hook.identities)) throw new Error(`${label}.identities must be an array.`);
-  const seen = { ids: new Set(), bindings: new Set() };
-  const identities = hook.identities.map((identity, identityIndex) => parseIdentity(identity, `${label}.identities[${identityIndex}]`, seen));
-  if (hook.kind === 'mutation' && !identities.some(identity => identity.resource)) throw new Error(`${label} mutation must declare at least one resource identity.`);
-  return { id: hook.id.trim(), path: source, export: hook.export, kind: hook.kind,
-    ...(hook.resultBinding === undefined ? {} : { resultBinding: hook.resultBinding }), identities };
+    exactKeys(hook, HOOK_KEYS, label);
+    if (typeof hook.id !== 'string' || !hook.id.trim() || ids.has(hook.id.trim()))
+        throw new Error(`${label}.id must be unique and non-empty.`);
+    ids.add(hook.id.trim());
+    const source = relativeSource(config.root, hook.path, `${label}.path`);
+    if (typeof hook.export !== 'string' || !/^use[A-Z0-9_$][\w$]*$/.test(hook.export))
+        throw new Error(`${label}.export must name one exported use* hook.`);
+    if (!['query', 'mutation'].includes(hook.kind))
+        throw new Error(`${label}.kind must be query or mutation.`);
+    if (hook.resultBinding !== undefined && (typeof hook.resultBinding !== 'string' || !IDENTIFIER.test(hook.resultBinding))) {
+        throw new Error(`${label}.resultBinding must be one local identifier.`);
+    }
+    if (!Array.isArray(hook.identities))
+        throw new Error(`${label}.identities must be an array.`);
+    const seen = { ids: new Set(), bindings: new Set() };
+    const identities = hook.identities.map((identity, identityIndex) => parseIdentity(identity, `${label}.identities[${identityIndex}]`, seen));
+    if (hook.kind === 'mutation' && !identities.some((identity) => identity.resource))
+        throw new Error(`${label} mutation must declare at least one resource identity.`);
+    return { id: hook.id.trim(), path: source, export: hook.export, kind: hook.kind,
+        ...(hook.resultBinding === undefined ? {} : { resultBinding: hook.resultBinding }), identities };
 }
-
 export function parseContract(config) {
-  // The contract is declared in the app's one package.json (the app root; config.root is the fe side folder).
-  const manifest = JSON.parse(fs.readFileSync(path.join(config.packageRoot ?? config.root, 'package.json'), 'utf8'));
-  const next = manifest?.starci?.codePatterns?.next;
-  const value = next?.dataLifecycle;
-  if (value === undefined) return null;
-  if (next.schema !== 'starci/next-code-pattern-contract@1') throw new Error('package.json#starci.codePatterns.next must use starci/next-code-pattern-contract@1.');
-  exactKeys(value, TOP_KEYS, CONTRACT_LABEL);
-  if (value.schema !== CONTRACT_SCHEMA) throw new Error(`dataLifecycle.schema must be ${CONTRACT_SCHEMA}.`);
-  parseSwr(value.swr);
-  if (!Array.isArray(value.hooks) || value.hooks.length === 0) throw new Error('dataLifecycle.hooks must contain at least one declared lifecycle call.');
-  const ids = new Set();
-  const hooks = value.hooks.map((hook, index) => parseHook(config, hook, `dataLifecycle.hooks[${index}]`, ids));
-  return { schema: value.schema, swr: { package: 'swr', major: value.swr.major }, hooks };
+    // The contract is declared in the app's one package.json (the app root; config.root is the fe side folder).
+    const manifest = JSON.parse(fs.readFileSync(path.join(config.packageRoot ?? config.root, 'package.json'), 'utf8'));
+    const next = manifest?.starci?.codePatterns?.next;
+    const value = next?.dataLifecycle;
+    if (value === undefined)
+        return null;
+    if (next.schema !== 'starci/next-code-pattern-contract@1')
+        throw new Error('package.json#starci.codePatterns.next must use starci/next-code-pattern-contract@1.');
+    exactKeys(value, TOP_KEYS, CONTRACT_LABEL);
+    if (value.schema !== CONTRACT_SCHEMA)
+        throw new Error(`dataLifecycle.schema must be ${CONTRACT_SCHEMA}.`);
+    parseSwr(value.swr);
+    if (!Array.isArray(value.hooks) || value.hooks.length === 0)
+        throw new Error('dataLifecycle.hooks must contain at least one declared lifecycle call.');
+    const ids = new Set();
+    const hooks = value.hooks.map((hook, index) => parseHook(config, hook, `dataLifecycle.hooks[${index}]`, ids));
+    return { schema: value.schema, swr: { package: 'swr', major: value.swr.major }, hooks };
 }
-
 export function installedSWR(repository) {
-  const require = createRequire(path.join(repository, 'package.json'));
-  let manifest;
-  try { manifest = require.resolve('swr/package.json'); } catch {
-    let entry;
-    try { entry = require.resolve('swr'); } catch { throw new Error('Installed swr package is unavailable.'); }
-    let current = path.dirname(entry);
-    while (isInside(repository, current) && current !== repository) {
-      const candidate = path.join(current, 'package.json');
-      if (fs.existsSync(candidate)) { manifest = candidate; break; }
-      current = path.dirname(current);
+    const require = createRequire(path.join(repository, 'package.json'));
+    let manifest;
+    try {
+        manifest = require.resolve('swr/package.json');
+    }
+    catch {
+        let entry;
+        try {
+            entry = require.resolve('swr');
+        }
+        catch {
+            throw new Error('Installed swr package is unavailable.');
+        }
+        let current = path.dirname(entry);
+        while (isInside(repository, current) && current !== repository) {
+            const candidate = path.join(current, 'package.json');
+            if (fs.existsSync(candidate)) {
+                manifest = candidate;
+                break;
+            }
+            current = path.dirname(current);
+        }
     }
-  }
-  if (!manifest) throw new Error('Installed swr package.json is unavailable.');
-  const actualManifest = canonical(manifest);
-  const parsed = JSON.parse(fs.readFileSync(actualManifest, 'utf8'));
-  const major = Number.parseInt(String(parsed.version ?? '').split('.')[0], 10);
-  if (parsed.name !== 'swr' || !Number.isInteger(major)) throw new Error('Installed swr package identity or version is invalid.');
-  return { name: parsed.name, version: parsed.version, major, root: canonical(path.dirname(actualManifest)) };
+    if (!manifest)
+        throw new Error('Installed swr package.json is unavailable.');
+    const actualManifest = canonical(manifest);
+    const parsed = JSON.parse(fs.readFileSync(actualManifest, 'utf8'));
+    const major = Number.parseInt(String(parsed.version ?? '').split('.')[0] ?? '', 10);
+    if (parsed.name !== 'swr' || !Number.isInteger(major))
+        throw new Error('Installed swr package identity or version is invalid.');
+    return { name: parsed.name, version: parsed.version, major, root: canonical(path.dirname(actualManifest)) };
 }

package/runtime/scripts/hfs/architecture/next-data-inference.d.mts

@@ -0,0 +1,39 @@
+import type { ArrowFunction, CallExpression, ElementAccessExpression, FunctionDeclaration, FunctionExpression, Node, PropertyAccessExpression, SourceFile, StringLiteralLike, Symbol as TsSymbol, TypeChecker } from 'typescript';
+import type { TypeScriptApi } from './config.mjs';
+/** A request input read lexically: its symbol, the name parts reaching it and whether it is imported. */
+export interface IdentityAccess {
+    symbol: TsSymbol | null | undefined;
+    parts: string[];
+    imported: boolean;
+}
+/** One inferred request identity of an SWR call. */
+export interface InferredIdentity extends IdentityAccess {
+    id: string;
+    binding: string;
+    gatesRequest: boolean;
+    resource: boolean;
+}
+/** The SWR call being inferred: where it is, its checker and whether it is a mutation. */
+export interface InferenceCall {
+    source: SourceFile;
+    node: CallExpression;
+    checker: TypeChecker;
+    kind: string;
+}
+/** The fetcher function, or the key expression, whose lexical inputs are inferred. */
+type Region = Node & {
+    body?: Node;
+};
+type Seen = Set<TsSymbol>;
+export type SelectedMember = PropertyAccessExpression | (ElementAccessExpression & {
+    argumentExpression: StringLiteralLike;
+});
+export declare function inferredFetcher(ts: TypeScriptApi, checker: TypeChecker, input: Node | null | undefined, seen?: Seen): FunctionDeclaration | ArrowFunction | FunctionExpression | null;
+/** Infer lexical request inputs; parameters declared inside the fetcher are supplied by SWR. */
+export declare function inferredIdentities(context: {
+    ts: TypeScriptApi;
+}, call: InferenceCall, region: Region, reasons: string[]): InferredIdentity[];
+export declare function inferredKeyBindings(context: {
+    ts: TypeScriptApi;
+}, call: InferenceCall, reasons: string[]): InferredIdentity[];
+export {};

package/runtime/scripts/hfs/architecture/next-data-inference.mjs

@@ -1,176 +1,192 @@
-// Infer lexical request identities for SWR hooks without a declared lifecycle contract.
 import { unwrapExpression } from './typescript.mjs';
 import { anyDescendant, normalizedSymbol } from './ast-walks.mjs';
 import { sourceLocation } from '../../lib/ts-ast.mjs';
 import { functionNode, constInitializer, inferredSymbol } from './next-data-symbols.mjs';
-
-export function inferredFetcher(ts, checker, expression, seen = new Set()) {
-  if (!expression) return null;
-  expression = unwrapExpression(ts, expression);
-  if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) return expression;
-  const symbol = normalizedSymbol(ts, checker, expression);
-  if (!symbol || seen.has(symbol)) return null;
-  for (const declaration of symbol.getDeclarations?.() ?? []) {
-    const fn = functionNode(ts, declaration);
-    if (fn) return fn;
-  }
-  const initializer = constInitializer(ts, symbol);
-  return initializer ? inferredFetcher(ts, checker, initializer, new Set(seen).add(symbol)) : null;
-}
-
+export function inferredFetcher(ts, checker, input, seen = new Set()) {
+    if (!input)
+        return null;
+    const expression = unwrapExpression(ts, input);
+    if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression))
+        return expression;
+    const symbol = normalizedSymbol(ts, checker, expression);
+    if (!symbol || seen.has(symbol))
+        return null;
+    for (const declaration of symbol.getDeclarations?.() ?? []) {
+        const fn = functionNode(ts, declaration);
+        if (fn)
+            return fn;
+    }
+    const initializer = constInitializer(ts, symbol);
+    return initializer ? inferredFetcher(ts, checker, initializer, new Set(seen).add(symbol)) : null;
+}
 function importedIdentityReference(ts, checker, expression) {
-  const reference = ts.isShorthandPropertyAssignment(expression.parent)
-    ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
-  return (reference?.getDeclarations?.() ?? []).some(declaration => ts.isImportSpecifier(declaration)
-    || ts.isImportClause(declaration) || ts.isNamespaceImport(declaration) || ts.isImportEqualsDeclaration(declaration));
+    const reference = ts.isShorthandPropertyAssignment(expression.parent)
+        ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+    return (reference?.getDeclarations?.() ?? []).some(declaration => ts.isImportSpecifier(declaration)
+        || ts.isImportClause(declaration) || ts.isNamespaceImport(declaration) || ts.isImportEqualsDeclaration(declaration));
 }
-
 function identifierIdentityAccess(ts, checker, expression, seen) {
-  const imported = importedIdentityReference(ts, checker, expression);
-  const symbol = inferredSymbol(ts, checker, expression);
-  const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
-  if (initializer) {
-    const alias = identityAccess(ts, checker, initializer, new Set(seen).add(symbol));
-    if (alias) return { ...alias, imported: imported || alias.imported };
-  }
-  return { symbol, parts: [expression.text], imported };
-}
-
+    const imported = importedIdentityReference(ts, checker, expression);
+    const symbol = inferredSymbol(ts, checker, expression);
+    const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
+    if (initializer && symbol) {
+        const alias = identityAccess(ts, checker, initializer, new Set(seen).add(symbol));
+        if (alias)
+            return { ...alias, imported: imported || alias.imported };
+    }
+    return { symbol, parts: [expression.text], imported };
+}
 function isSelectedMember(ts, expression) {
-  return ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)
-    && ts.isStringLiteralLike(expression.argumentExpression);
+    return ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)
+        && ts.isStringLiteralLike(expression.argumentExpression);
 }
-
 function selectedMemberKey(ts, expression) {
-  return ts.isPropertyAccessExpression(expression) ? expression.name.text : expression.argumentExpression.text;
-}
-
-function identityAccess(ts, checker, expression, seen = new Set()) {
-  expression = unwrapExpression(ts, expression);
-  if (ts.isIdentifier(expression)) return identifierIdentityAccess(ts, checker, expression, seen);
-  if (isSelectedMember(ts, expression)) {
-    const base = identityAccess(ts, checker, expression.expression, seen);
-    return base ? { ...base, parts: [...base.parts, selectedMemberKey(ts, expression)] } : null;
-  }
-  return null;
-}
-
+    return ts.isPropertyAccessExpression(expression) ? expression.name.text : expression.argumentExpression.text;
+}
+function identityAccess(ts, checker, input, seen = new Set()) {
+    const expression = unwrapExpression(ts, input);
+    if (ts.isIdentifier(expression))
+        return identifierIdentityAccess(ts, checker, expression, seen);
+    if (isSelectedMember(ts, expression)) {
+        const base = identityAccess(ts, checker, expression.expression, seen);
+        return base ? { ...base, parts: [...base.parts, selectedMemberKey(ts, expression)] } : null;
+    }
+    return null;
+}
 function containerWritten(ts, checker, symbol, source) {
-  const rootSymbol = expression => {
-    expression = unwrapExpression(ts, expression);
-    while (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) expression = unwrapExpression(ts, expression.expression);
-    return ts.isIdentifier(expression) ? inferredSymbol(ts, checker, expression) : null;
-  };
-  return anyDescendant(ts, source, node => {
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
-      && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) return rootSymbol(node.left) === symbol;
-    if (ts.isDeleteExpression(node)) return rootSymbol(node.expression) === symbol;
-    if (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)
-      && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator)) return rootSymbol(node.operand) === symbol;
-    return false;
-  });
-}
-
+    const incrementOperators = [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken];
+    const rootSymbol = (input) => {
+        let expression = unwrapExpression(ts, input);
+        while (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression))
+            expression = unwrapExpression(ts, expression.expression);
+        return ts.isIdentifier(expression) ? inferredSymbol(ts, checker, expression) : null;
+    };
+    return anyDescendant(ts, source, (node) => {
+        if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment
+            && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+            return rootSymbol(node.left) === symbol;
+        if (ts.isDeleteExpression(node))
+            return rootSymbol(node.expression) === symbol;
+        if (ts.isPostfixUnaryExpression(node) || ts.isPrefixUnaryExpression(node)
+            && incrementOperators.includes(node.operator))
+            return rootSymbol(node.operand) === symbol;
+        return false;
+    });
+}
 function selectedRequestAlias(ts, checker, expression, seen) {
-  const symbol = inferredSymbol(ts, checker, expression);
-  const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
-  if (!initializer) return null;
-  const value = unwrapExpression(ts, initializer);
-  if (ts.isObjectLiteralExpression(value) && (initializer.getSourceFile() !== expression.getSourceFile()
-    || containerWritten(ts, checker, symbol, expression.getSourceFile()))) return null;
-  if (ts.isObjectLiteralExpression(value) || ts.isIdentifier(value) || ts.isPropertyAccessExpression(value)
-    || ts.isElementAccessExpression(value)) return { symbol, value };
-  return null;
-}
-
+    const symbol = inferredSymbol(ts, checker, expression);
+    const initializer = symbol && !seen.has(symbol) ? constInitializer(ts, symbol) : null;
+    if (!initializer || !symbol)
+        return null;
+    const value = unwrapExpression(ts, initializer);
+    if (ts.isObjectLiteralExpression(value) && (initializer.getSourceFile() !== expression.getSourceFile()
+        || containerWritten(ts, checker, symbol, expression.getSourceFile())))
+        return null;
+    if (ts.isObjectLiteralExpression(value) || ts.isIdentifier(value) || ts.isPropertyAccessExpression(value)
+        || ts.isElementAccessExpression(value))
+        return { symbol, value };
+    return null;
+}
 function selectedRequestProperty(ts, object, key) {
-  if (!ts.isObjectLiteralExpression(object) || !object.properties.every(property => ts.isPropertyAssignment(property)
-    || ts.isShorthandPropertyAssignment(property))) return null;
-  return [...object.properties].reverse().find(candidate => (ts.isIdentifier(candidate.name)
-    || ts.isStringLiteralLike(candidate.name)) && candidate.name.text === key) ?? null;
-}
-
-function selectedRequestValue(ts, checker, expression, seen = new Set()) {
-  expression = unwrapExpression(ts, expression);
-  if (ts.isIdentifier(expression)) {
-    const alias = selectedRequestAlias(ts, checker, expression, seen);
-    return alias ? selectedRequestValue(ts, checker, alias.value, new Set(seen).add(alias.symbol)) : expression;
-  }
-  if (!isSelectedMember(ts, expression)) return expression;
-  const object = selectedRequestValue(ts, checker, expression.expression, seen);
-  const property = selectedRequestProperty(ts, object, selectedMemberKey(ts, expression));
-  if (!property) return expression;
-  const value = ts.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
-  return selectedRequestValue(ts, checker, value, seen);
-}
-
+    if (!ts.isObjectLiteralExpression(object) || !object.properties.every((property) => ts.isPropertyAssignment(property)
+        || ts.isShorthandPropertyAssignment(property)))
+        return null;
+    return [...object.properties].reverse().find(candidate => (ts.isIdentifier(candidate.name)
+        || ts.isStringLiteralLike(candidate.name)) && candidate.name.text === key) ?? null;
+}
+function selectedRequestValue(ts, checker, input, seen = new Set()) {
+    const expression = unwrapExpression(ts, input);
+    if (ts.isIdentifier(expression)) {
+        const alias = selectedRequestAlias(ts, checker, expression, seen);
+        return alias ? selectedRequestValue(ts, checker, alias.value, new Set(seen).add(alias.symbol)) : expression;
+    }
+    if (!isSelectedMember(ts, expression))
+        return expression;
+    const object = selectedRequestValue(ts, checker, expression.expression, seen);
+    const property = selectedRequestProperty(ts, object, selectedMemberKey(ts, expression));
+    if (!property)
+        return expression;
+    const value = ts.isShorthandPropertyAssignment(property) ? property.name : property.initializer;
+    return selectedRequestValue(ts, checker, value, seen);
+}
 function capturedInput(ts, access, region) {
-  const declarations = access.symbol?.getDeclarations?.() ?? [];
-  return declarations.some(declaration => {
-    if (declaration.getSourceFile() === region.getSourceFile() && declaration.pos >= region.pos && declaration.end <= region.end) return false;
-    if (declaration.getSourceFile().isDeclarationFile && !access.imported) return false;
-    return access.imported || ts.isVariableDeclaration(declaration) || ts.isParameter(declaration) || ts.isBindingElement(declaration);
-  });
-}
-
+    const declarations = access.symbol?.getDeclarations?.() ?? [];
+    return declarations.some(declaration => {
+        if (declaration.getSourceFile() === region.getSourceFile() && declaration.pos >= region.pos && declaration.end <= region.end)
+            return false;
+        if (declaration.getSourceFile().isDeclarationFile && !access.imported)
+            return false;
+        return access.imported || ts.isVariableDeclaration(declaration) || ts.isParameter(declaration) || ts.isBindingElement(declaration);
+    });
+}
 function capturedIdentityAlias(ts, access, seen) {
-  // Follow transparent aliases and request objects, so {id} and an alias of id carry the same identity.
-  if (access.parts.length !== 1 || seen.has(access.symbol)) return null;
-  const initializer = constInitializer(ts, access.symbol);
-  if (!initializer) return null;
-  const value = unwrapExpression(ts, initializer);
-  return ts.isCallExpression(value) || ts.isAwaitExpression(value) || ts.isNewExpression(value) ? null : value;
-}
-
+    // Follow transparent aliases and request objects, so {id} and an alias of id carry the same identity.
+    if (access.parts.length !== 1 || (access.symbol ? seen.has(access.symbol) : false))
+        return null;
+    const initializer = constInitializer(ts, access.symbol);
+    if (!initializer)
+        return null;
+    const value = unwrapExpression(ts, initializer);
+    return ts.isCallExpression(value) || ts.isAwaitExpression(value) || ts.isNewExpression(value) ? null : value;
+}
 function recordInferredIdentity(scope, access, seen, visit) {
-  const { ts, call, region, reasons, identities } = scope;
-  if (access?.imported && !(access.symbol?.getDeclarations?.() ?? []).length) {
-    reasons.push(`${call.source.fileName}:${sourceLocation(call.source, call.node).line} imported SWR request input ${access.parts.join('.')} cannot be resolved; dataLifecycle is required to declare identities`);
+    const { ts, call, region, reasons, identities } = scope;
+    if (access?.imported && !(access.symbol?.getDeclarations?.() ?? []).length) {
+        reasons.push(`${call.source.fileName}:${sourceLocation(call.source, call.node).line} imported SWR request input ${access.parts.join('.')} cannot be resolved; dataLifecycle is required to declare identities`);
+        return true;
+    }
+    if (!access || !capturedInput(ts, access, region))
+        return false;
+    const alias = capturedIdentityAlias(ts, access, seen);
+    if (alias && access.symbol)
+        visit(alias, new Set(seen).add(access.symbol));
+    else {
+        const binding = access.parts.join('.');
+        identities.set(binding, { id: binding, binding, ...access, gatesRequest: false, resource: call.kind === 'mutation' });
+    }
     return true;
-  }
-  if (!access || !capturedInput(ts, access, region)) return false;
-  const alias = capturedIdentityAlias(ts, access, seen);
-  if (alias) visit(alias, new Set(seen).add(access.symbol));
-  else {
-    const binding = access.parts.join('.');
-    identities.set(binding, { id: binding, binding, ...access, gatesRequest: false, resource: call.kind === 'mutation' });
-  }
-  return true;
-}
-
+}
 function visitRequestChildren(ts, node, seen, visit) {
-  if (ts.isPropertyAssignment(node)) { visit(node.initializer, seen); return; }
-  // A method name is not a request input; its receiver and arguments can be.
-  if (ts.isCallExpression(node)) {
-    const callee = unwrapExpression(ts, node.expression);
-    if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) visit(callee.expression, seen);
-    for (const argument of node.arguments) visit(argument, seen);
-    return;
-  }
-  if (ts.isVariableDeclaration(node)) {
-    if (node.initializer) visit(node.initializer, seen);
-    return;
-  }
-  ts.forEachChild(node, child => { visit(child, seen); });
-}
-
+    if (ts.isPropertyAssignment(node)) {
+        visit(node.initializer, seen);
+        return;
+    }
+    // A method name is not a request input; its receiver and arguments can be.
+    if (ts.isCallExpression(node)) {
+        const callee = unwrapExpression(ts, node.expression);
+        if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee))
+            visit(callee.expression, seen);
+        for (const argument of node.arguments)
+            visit(argument, seen);
+        return;
+    }
+    if (ts.isVariableDeclaration(node)) {
+        if (node.initializer)
+            visit(node.initializer, seen);
+        return;
+    }
+    ts.forEachChild(node, (child) => { visit(child, seen); });
+}
 /** Infer lexical request inputs; parameters declared inside the fetcher are supplied by SWR. */
 export function inferredIdentities(context, call, region, reasons) {
-  const { ts } = context;
-  const identities = new Map();
-  const scope = { ts, call, region, reasons, identities };
-  const visit = (node, seen = new Set()) => {
-    const selectedValue = selectedRequestValue(ts, call.checker, node);
-    if (selectedValue !== node && selectedValue !== unwrapExpression(ts, node)) { visit(selectedValue, seen); return; }
-    if (recordInferredIdentity(scope, identityAccess(ts, call.checker, node), seen, visit)) return;
-    visitRequestChildren(ts, node, seen, visit);
-  };
-  visit(region.body ?? region);
-  return [...identities.values()];
-}
-
+    const { ts } = context;
+    const identities = new Map();
+    const scope = { ts, call, region, reasons, identities };
+    const visit = (node, seen = new Set()) => {
+        const selectedValue = selectedRequestValue(ts, call.checker, node);
+        if (selectedValue !== node && selectedValue !== unwrapExpression(ts, node)) {
+            visit(selectedValue, seen);
+            return;
+        }
+        if (recordInferredIdentity(scope, identityAccess(ts, call.checker, node), seen, visit))
+            return;
+        visitRequestChildren(ts, node, seen, visit);
+    };
+    visit(region.body ?? region);
+    return [...identities.values()];
+}
 export function inferredKeyBindings(context, call, reasons) {
-  const key = call.node.arguments[0];
-  // A key or its null guard can contain bindings that are not captured request inputs.
-  return key ? inferredIdentities(context, call, key, reasons).map(identity => ({ ...identity, id: `key:${identity.id}`, resource: false })) : [];
+    const key = call.node.arguments[0];
+    // A key or its null guard can contain bindings that are not captured request inputs.
+    return key ? inferredIdentities(context, call, key, reasons).map(identity => ({ ...identity, id: `key:${identity.id}`, resource: false })) : [];
 }