@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/vendor/dynamic-workflow/analysis/callbacks.d.ts

@@ -0,0 +1,71 @@
+import ts from "typescript";
+/**
+ * The callback-semantics registry: the ONE place that says what a library callee does with
+ * the script-local functions handed to it.
+ *
+ * Invocation is a semantic fact. The taint listener already treats functions as values and
+ * applies whatever reaches a call (directly, or pessimistically through the keystone rule
+ * for unknown callees). The ordering listener must NOT guess from syntax what the taint
+ * listener knows from values — so the only thing left to write down is what the taint
+ * domain cannot express: how OFTEN a library invokes its callback and whether it PROVABLY
+ * does. Both listeners read this table; neither keeps a private whitelist.
+ *
+ *  - `each`: the callback runs once per element of `iterated`. The site table turns such a
+ *    call into an iteration candidate (a fan-out relay, promoted when its body reaches a
+ *    facade site); the ordering walk opens a `fanout` region around the body.
+ *  - `once`: the callback runs at most once. The ordering walk opens a `call` region,
+ *    `entered` iff the library provably invokes it (a `Promise` executor, `.finally`).
+ *
+ * A callee with no entry gets {@link DEFAULT_CALLBACK_SEMANTICS}: once, not entered, every
+ * argument a potential callback — exactly the set the taint keystone applies, so no function
+ * value that reaches a call is ever left for the end-of-walk sweep.
+ *
+ * Deliberately NOT here: `.call` / `.apply` / `.bind` (they forward the CALLEE, not a callback;
+ * calls.ts routes those through the callee application path) and the facade's own functions.
+ */
+export type CallbackMultiplicity = "each" | "once";
+export interface CallbackSemantics {
+    multiplicity: CallbackMultiplicity;
+    /** Running the call provably runs the callback body (at least once). */
+    entered: boolean;
+    /** Argument indices that may hold callbacks, in order. */
+    callbacks: readonly number[];
+    /** Display / region label: the method or global function name. */
+    label: string;
+    /**
+     * `once` only: the callback runs AFTER the receiver settles (a promise continuation, a
+     * timer), not during the call. The ordering walk places the body at the call site and
+     * opens it with a may-barrier over the receiver, so the receiver's steps precede the
+     * callback's without the continuation being mistaken for a synchronous call.
+     */
+    deferred?: true;
+    /** `each` only: the expression the callback is applied to element-wise. */
+    iterated?: ts.Expression;
+    /** `each` only: callback parameter indices that receive an ELEMENT. */
+    elementParams?: readonly number[];
+    /** `each` only: callback parameter indices that receive the WHOLE collection. */
+    wholeParams?: readonly number[];
+    /** `each` only: the callback parameter index that receives the accumulator (`reduce`). */
+    accumulatorParam?: number;
+}
+/** What an unknown callee is assumed to do with function-valued arguments. */
+export declare const DEFAULT_CALLBACK_SEMANTICS: Pick<CallbackSemantics, "multiplicity" | "entered">;
+/**
+ * The registry entry for a call or `new`, or undefined when the callee has none (callers
+ * fall back to {@link DEFAULT_CALLBACK_SEMANTICS} for whatever function values reach it).
+ * Never matches a callee declared in the authored script: a script-local `then` is a
+ * script-local function, applied through the callee path.
+ */
+export declare function callbackSemanticsOf(node: ts.CallExpression | ts.NewExpression, checker: ts.TypeChecker, program: ts.Program): CallbackSemantics | undefined;
+/** True iff `expr` resolves to the ES-lib global `name` (not a user shadow). */
+export declare function isGlobalLibValue(expr: ts.Expression, name: string, checker: ts.TypeChecker, program: ts.Program): boolean;
+/**
+ * True iff the member is DECLARED, and nowhere in the authored script: a library or facade
+ * method (`p.finally`, `xs.map`, `node.ask`). Such a member can never BE a script function,
+ * however many function values the receiver's abstract value happens to carry — a whole-value
+ * read of a container with an absent field collapses to everything in it, callables included,
+ * and dispatching on those would inline callbacks as the callee of `.finally`. An undeclared
+ * member (an `any` receiver) keeps the value-based answer.
+ */
+export declare function isForeignMember(name: ts.MemberName, checker: ts.TypeChecker, scriptFile: ts.SourceFile): boolean;
+//# sourceMappingURL=callbacks.d.ts.map

package/vendor/dynamic-workflow/analysis/callbacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.d.ts","sourceRoot":"","sources":["../../src/analysis/callbacks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,oBAAoB,CAAC;IACnC,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC;IACzB,uEAAuE;IACvE,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,iFAAiF;IACjF,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC,0FAA0F;IAC1F,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,8EAA8E;AAC9E,eAAO,MAAM,0BAA0B,EAAE,IAAI,CAAC,iBAAiB,EAAE,cAAc,GAAG,SAAS,CAG1F,CAAC;AAwCF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,EAAE,CAAC,aAAa,EAC1C,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,OAAO,EAAE,EAAE,CAAC,OAAO,GAClB,iBAAiB,GAAG,SAAS,CAyC/B;AAWD,gFAAgF;AAChF,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,OAAO,EAAE,EAAE,CAAC,OAAO,GAClB,OAAO,CAKT;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,OAAO,CAIhH"}

package/vendor/dynamic-workflow/analysis/callbacks.js

@@ -0,0 +1,133 @@
+import ts from "typescript";
+import { FACADE_FILE_NAME } from "../facade/dts.js";
+/** What an unknown callee is assumed to do with function-valued arguments. */
+export const DEFAULT_CALLBACK_SEMANTICS = {
+    entered: false,
+    multiplicity: "once",
+};
+/** Array methods that invoke their callback per element. Name-based on any receiver that is
+ * not a script-declared method (a user class's own `.map` is a user function: callee path).
+ * Value: element / whole-collection / accumulator parameter indices of the callback. */
+const EACH_METHODS = new Map([
+    ["map", { element: [0], whole: [2] }],
+    ["flatMap", { element: [0], whole: [2] }],
+    ["forEach", { element: [0], whole: [2] }],
+    ["filter", { element: [0], whole: [2] }],
+    ["some", { element: [0], whole: [2] }],
+    ["every", { element: [0], whole: [2] }],
+    ["find", { element: [0], whole: [2] }],
+    ["findIndex", { element: [0], whole: [2] }],
+    ["findLast", { element: [0], whole: [2] }],
+    ["findLastIndex", { element: [0], whole: [2] }],
+    ["reduce", { accumulator: 0, element: [1], whole: [3] }],
+    ["reduceRight", { accumulator: 0, element: [1], whole: [3] }],
+    ["sort", { element: [0, 1], whole: [] }],
+]);
+/** Promise continuation methods: run at most once, after the receiver settles. */
+const ONCE_METHODS = new Map([
+    ["then", { callbacks: [0, 1], deferred: true, entered: false }],
+    ["catch", { callbacks: [0], deferred: true, entered: false }],
+    ["finally", { callbacks: [0], deferred: true, entered: true }],
+]);
+/** Global scheduling functions: run their callback once, later. */
+const ONCE_GLOBALS = new Set(["setTimeout", "setInterval", "setImmediate", "queueMicrotask"]);
+/**
+ * The one facade function that takes a callback: `future(body)` starts `body` at the call
+ * and returns its promise (docs/dynamic-workflow/authoring.md「Streams」). Once and ENTERED —
+ * the cell provably calls it — and NOT deferred: it runs now, not after anything settles, so
+ * the ordering walk inlines the body as an entered `call` region, a strand when it is async.
+ */
+const FUTURE_FUNCTION = "future";
+/**
+ * The registry entry for a call or `new`, or undefined when the callee has none (callers
+ * fall back to {@link DEFAULT_CALLBACK_SEMANTICS} for whatever function values reach it).
+ * Never matches a callee declared in the authored script: a script-local `then` is a
+ * script-local function, applied through the callee path.
+ */
+export function callbackSemanticsOf(node, checker, program) {
+    const args = node.arguments ?? [];
+    if (ts.isNewExpression(node)) {
+        if (isGlobalLibValue(node.expression, "Promise", checker, program) && args.length > 0) {
+            return { callbacks: [0], entered: true, label: "Promise", multiplicity: "once" };
+        }
+        return undefined;
+    }
+    const callee = node.expression;
+    if (ts.isPropertyAccessExpression(callee)) {
+        if (isScriptDeclared(callee.name, checker, program))
+            return undefined;
+        const method = callee.name.text;
+        if (method === "from" && isGlobalLibValue(callee.expression, "Array", checker, program)) {
+            const iterated = args[0];
+            if (iterated === undefined || args.length < 2)
+                return undefined;
+            return { callbacks: [1], elementParams: [0], entered: false, iterated, label: "from", multiplicity: "each", wholeParams: [] };
+        }
+        const each = EACH_METHODS.get(method);
+        if (each !== undefined) {
+            return {
+                callbacks: [0],
+                elementParams: each.element,
+                entered: false,
+                iterated: callee.expression,
+                label: method,
+                multiplicity: "each",
+                wholeParams: each.whole,
+                ...(each.accumulator === undefined ? {} : { accumulatorParam: each.accumulator }),
+            };
+        }
+        const once = ONCE_METHODS.get(method);
+        if (once !== undefined)
+            return { ...once, label: method, multiplicity: "once" };
+        return undefined;
+    }
+    if (ts.isIdentifier(callee) && ONCE_GLOBALS.has(callee.text) && isGlobalLibValue(callee, callee.text, checker, program)) {
+        return { callbacks: [0], deferred: true, entered: false, label: callee.text, multiplicity: "once" };
+    }
+    if (ts.isIdentifier(callee) && callee.text === FUTURE_FUNCTION && isFacadeFunction(callee, checker)) {
+        return { callbacks: [0], entered: true, label: FUTURE_FUNCTION, multiplicity: "once" };
+    }
+    return undefined;
+}
+/** True iff `expr` resolves to a function declared in the facade `.d.ts` (not a user shadow). */
+function isFacadeFunction(expr, checker) {
+    let symbol = checker.getSymbolAtLocation(expr);
+    if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0)
+        symbol = checker.getAliasedSymbol(symbol);
+    return (symbol?.declarations?.some((declaration) => declaration.getSourceFile().fileName === FACADE_FILE_NAME) ?? false);
+}
+/** True iff `expr` resolves to the ES-lib global `name` (not a user shadow). */
+export function isGlobalLibValue(expr, name, checker, program) {
+    let symbol = checker.getSymbolAtLocation(expr);
+    if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0)
+        symbol = checker.getAliasedSymbol(symbol);
+    if (symbol?.name !== name)
+        return false;
+    return symbol.declarations?.some((declaration) => isLibDeclaration(declaration, program)) ?? false;
+}
+/**
+ * True iff the member is DECLARED, and nowhere in the authored script: a library or facade
+ * method (`p.finally`, `xs.map`, `node.ask`). Such a member can never BE a script function,
+ * however many function values the receiver's abstract value happens to carry — a whole-value
+ * read of a container with an absent field collapses to everything in it, callables included,
+ * and dispatching on those would inline callbacks as the callee of `.finally`. An undeclared
+ * member (an `any` receiver) keeps the value-based answer.
+ */
+export function isForeignMember(name, checker, scriptFile) {
+    const declarations = checker.getSymbolAtLocation(name)?.declarations;
+    if (declarations === undefined || declarations.length === 0)
+        return false;
+    return declarations.every((declaration) => declaration.getSourceFile() !== scriptFile);
+}
+/** True iff the member's symbol has a declaration in the authored script (a user method). */
+function isScriptDeclared(name, checker, program) {
+    const symbol = checker.getSymbolAtLocation(name);
+    return (symbol?.declarations?.some((declaration) => {
+        const file = declaration.getSourceFile();
+        return !isLibDeclaration(declaration, program) && !file.isDeclarationFile;
+    }) ?? false);
+}
+function isLibDeclaration(declaration, program) {
+    const file = declaration.getSourceFile();
+    return program.isSourceFileDefaultLibrary(file) || /^lib\..+\.d\.ts$/.test(file.fileName);
+}

package/vendor/dynamic-workflow/analysis/calls.d.ts

@@ -0,0 +1,40 @@
+import ts from "typescript";
+import { type AbstractValue } from "./domain.js";
+import type { EvalContext, Evaluator } from "./taint.js";
+import type { ApplicationVia } from "./state.js";
+/**
+ * Call and relay transfer rules: the facade sinks (`ask`, `files.*`), the relay
+ * nodes (`Promise.all` joins and promoted iteration fan-outs), heap mutators, and
+ * script-local / higher-order function calls with context-sensitive summaries. These
+ * live apart from the core evaluator (taint.ts) but operate on the same `Evaluator`
+ * instance.
+ */
+export declare function evalCall(ev: Evaluator, node: ts.CallExpression, ctx: EvalContext): AbstractValue;
+/**
+ * Apply a callee to already-evaluated argument values. Shared by ordinary call
+ * expressions and tagged templates (``tag`…${e}…` `` is the call `tag(strings, e, …)`).
+ * Script-local callees route through their context-sensitive summary; unknown/library
+ * callees widen (see {@link handleUnknownCall}). `argPlaces[i]`, when present, is the
+ * live value of a place actual, used for parameter write-back. `tail`, when present, is an
+ * inexact spread smear bound to every parameter at index >= `argVals.length`. `site` is the
+ * call / tagged-template node the application is recorded against (the call oracle).
+ */
+export declare function applyCall(ev: Evaluator, calleeExpr: ts.Expression, argVals: AbstractValue[], ctx: EvalContext, argPlaces?: (AbstractValue | undefined)[], tail?: AbstractValue, site?: ts.Node): AbstractValue;
+/**
+ * Keystone application of every script-local function reachable in `source`: each of its
+ * parameters receives `pot` (already exactness-cleared), and its substituted return summary
+ * joins `out`. Shared by {@link handleUnknownCall} and {@link handleNewUnknown} (`new`).
+ */
+export declare function applyPessimistically(ev: Evaluator, source: AbstractValue, pot: AbstractValue, ctx: EvalContext, out: AbstractValue, site?: ts.Node): void;
+/**
+ * Apply script-local functions handed to a per-element library call (`xs.map(review)`) with
+ * positional actuals already shaped by the registry (element / whole / accumulator slots).
+ * Records each as an `argument` application at `site` inside the candidate's region stack and
+ * returns the union of the substituted return summaries (inexact: the dispatch is indirect).
+ */
+export declare function applyCallbackFns(ev: Evaluator, fns: readonly ts.Node[], actuals: AbstractValue[], regionStack: string[], site: ts.Node): AbstractValue;
+export declare function recordCall(ev: Evaluator, id: number, regionStack: string[], argVals: AbstractValue[], argPlaces?: (AbstractValue | undefined)[], application?: {
+    site: ts.Node;
+    via: ApplicationVia;
+}): void;
+//# sourceMappingURL=calls.d.ts.map

package/vendor/dynamic-workflow/analysis/calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calls.d.ts","sourceRoot":"","sources":["../../src/analysis/calls.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAgBL,KAAK,aAAa,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AASjD;;;;;;GAMG;AAEH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,cAAc,EAAE,GAAG,EAAE,WAAW,GAAG,aAAa,CAsEhG;AAiHD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,EAAE,EAAE,SAAS,EACb,UAAU,EAAE,EAAE,CAAC,UAAU,EACzB,OAAO,EAAE,aAAa,EAAE,EACxB,GAAG,EAAE,WAAW,EAChB,SAAS,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EACzC,IAAI,CAAC,EAAE,aAAa,EACpB,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,GACb,aAAa,CAUf;AAsID;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,SAAS,EACb,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,aAAa,EAClB,GAAG,EAAE,WAAW,EAChB,GAAG,EAAE,aAAa,EAClB,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,GACb,IAAI,CAQN;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,SAAS,EACb,GAAG,EAAE,SAAS,EAAE,CAAC,IAAI,EAAE,EACvB,OAAO,EAAE,aAAa,EAAE,EACxB,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,EAAE,CAAC,IAAI,GACZ,aAAa,CASf;AAOD,wBAAgB,UAAU,CACxB,EAAE,EAAE,SAAS,EACb,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,EAAE,EACrB,OAAO,EAAE,aAAa,EAAE,EACxB,SAAS,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,EACzC,WAAW,CAAC,EAAE;IAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IAAC,GAAG,EAAE,cAAc,CAAA;CAAE,GACnD,IAAI,CA+BN"}