@suss/packs 0.11.0

package/dist/node.d.ts

@@ -0,0 +1 @@
+export { default } from '@suss/runtime-node';

package/dist/node.js

@@ -0,0 +1,667 @@
+// ../runtime/node/dist/index.js
+import {
+  Node as N,
+  VariableDeclarationKind
+} from "ts-morph";
+import { runtimeConfigBinding } from "@suss/behavioral-ir";
+import { Node } from "ts-morph";
+import { runtimeConfigBinding as runtimeConfigBinding2 } from "@suss/behavioral-ir";
+import {
+  Node as Node2
+} from "ts-morph";
+import { runtimeConfigBinding as runtimeConfigBinding3 } from "@suss/behavioral-ir";
+import {
+  Node as Node3
+} from "ts-morph";
+import { functionCallBinding } from "@suss/behavioral-ir";
+var readName = (name) => `process.env.${name}`;
+function isProcessEnv(node) {
+  if (!N.isPropertyAccessExpression(node) || node.getName() !== "env") {
+    return false;
+  }
+  const root = node.getExpression();
+  return N.isIdentifier(root) && root.getText() === "process";
+}
+function dottedRead(node) {
+  if (!isProcessEnv(node.getExpression())) {
+    return [];
+  }
+  return [{ name: node.getName(), defaulted: isDefaultedAt(node), node }];
+}
+function bracketRead(access) {
+  const argument = access.getArgumentExpression();
+  if (argument === void 0) {
+    return [];
+  }
+  if (N.isStringLiteral(argument) || N.isNoSubstitutionTemplateLiteral(argument)) {
+    const name = argument.getLiteralValue();
+    if (name.length === 0) {
+      return [];
+    }
+    return [{ name, defaulted: isDefaultedAt(access), node: access }];
+  }
+  if (N.isIdentifier(argument)) {
+    return readsThroughParameter(access, argument);
+  }
+  return [];
+}
+var CALLER_LOOKUPS = /* @__PURE__ */ new WeakMap();
+function readsThroughParameter(access, index) {
+  const remembered = CALLER_LOOKUPS.get(access);
+  if (remembered !== void 0) {
+    return remembered;
+  }
+  const found = callerLiteralReads(access, index);
+  CALLER_LOOKUPS.set(access, found);
+  return found;
+}
+function callerLiteralReads(access, index) {
+  const enclosing = enclosingFunction(access);
+  if (enclosing === void 0) {
+    return [];
+  }
+  const at = enclosing.getParameters().findIndex((parameter) => parameter.getName() === index.getText());
+  if (at === -1) {
+    return [];
+  }
+  const defaulted = isDefaultedAt(access);
+  const reads = [];
+  const pending = [{ fn: enclosing, at }];
+  const taken = /* @__PURE__ */ new Set();
+  while (pending.length > 0) {
+    const wanted = pending.pop();
+    const key = `${wanted.fn.getPos()}:${wanted.at}`;
+    if (taken.has(key)) {
+      continue;
+    }
+    taken.add(key);
+    for (const call of callSitesOf(wanted.fn)) {
+      const passed = call.getArguments()[wanted.at];
+      if (passed === void 0) {
+        continue;
+      }
+      const literal = literalBehind(passed);
+      if (literal !== null && literal.length > 0) {
+        reads.push({ name: literal, defaulted, node: call });
+        continue;
+      }
+      const forwarded = forwardedParameter(passed, call);
+      if (forwarded !== null) {
+        pending.push(forwarded);
+      }
+    }
+  }
+  return reads;
+}
+function enclosingFunction(node) {
+  return node.getFirstAncestor(
+    (candidate) => N.isFunctionDeclaration(candidate) || N.isArrowFunction(candidate) || N.isFunctionExpression(candidate) || N.isMethodDeclaration(candidate)
+  );
+}
+function literalBehind(passed) {
+  if (N.isStringLiteral(passed) || N.isNoSubstitutionTemplateLiteral(passed)) {
+    return passed.getLiteralValue();
+  }
+  if (!N.isIdentifier(passed)) {
+    return null;
+  }
+  for (const definition of passed.getDefinitionNodes()) {
+    if (!N.isVariableDeclaration(definition)) {
+      continue;
+    }
+    const initializer = definition.getInitializer();
+    if (initializer !== void 0 && definition.getVariableStatement()?.getDeclarationKind() === VariableDeclarationKind.Const && (N.isStringLiteral(initializer) || N.isNoSubstitutionTemplateLiteral(initializer))) {
+      return initializer.getLiteralValue();
+    }
+  }
+  return null;
+}
+function forwardedParameter(passed, call) {
+  if (!N.isIdentifier(passed)) {
+    return null;
+  }
+  const caller = enclosingFunction(call);
+  if (caller === void 0) {
+    return null;
+  }
+  const at = caller.getParameters().findIndex((parameter) => parameter.getName() === passed.getText());
+  return at === -1 ? null : { fn: caller, at };
+}
+function callSitesOf(fn) {
+  const named = N.isVariableDeclaration(fn.getParent()) ? fn.getParent().getNameNode() : fn.getNameNode?.();
+  if (named === void 0 || !N.isIdentifier(named)) {
+    return [];
+  }
+  const calls = [];
+  for (const reference of named.findReferencesAsNodes()) {
+    const parent = reference.getParent();
+    if (parent === void 0) {
+      continue;
+    }
+    if (N.isCallExpression(parent) && parent.getExpression() === reference) {
+      calls.push(parent);
+      continue;
+    }
+    if (N.isPropertyAccessExpression(parent) && parent.getNameNode() === reference) {
+      const grandparent = parent.getParent();
+      if (grandparent !== void 0 && N.isCallExpression(grandparent) && grandparent.getExpression() === parent) {
+        calls.push(grandparent);
+      }
+    }
+  }
+  return calls;
+}
+function bindingRead(element) {
+  if (element.getDotDotDotToken() !== void 0) {
+    return [];
+  }
+  const named = element.getPropertyNameNode() ?? element.getNameNode();
+  if (!(N.isIdentifier(named) || N.isStringLiteral(named))) {
+    return [];
+  }
+  const name = N.isIdentifier(named) ? named.getText() : named.getLiteralValue();
+  if (name.length === 0) {
+    return [];
+  }
+  return [
+    {
+      name,
+      // A binding default supplies the value the variable is missing,
+      // which is what `??` does for the other two spellings.
+      defaulted: element.getInitializer() !== void 0,
+      node: element
+    }
+  ];
+}
+function destructuredReads(declaration) {
+  const pattern = declaration.getNameNode();
+  if (!N.isObjectBindingPattern(pattern)) {
+    return [];
+  }
+  return pattern.getElements().flatMap(bindingRead);
+}
+function readsThroughEnvObject(envNode) {
+  const parent = envNode.getParent();
+  if (N.isElementAccessExpression(parent)) {
+    return bracketRead(parent);
+  }
+  if (N.isVariableDeclaration(parent)) {
+    return destructuredReads(parent);
+  }
+  return [];
+}
+function envReadsAt(node) {
+  if (N.isCallExpression(node)) {
+    return readsThroughHelperCall(node);
+  }
+  if (!N.isPropertyAccessExpression(node)) {
+    return [];
+  }
+  return isProcessEnv(node) ? readsThroughEnvObject(node) : dottedRead(node);
+}
+function readsThroughHelperCall(call) {
+  const reads = [];
+  const callee = functionBehindCallee(call.getExpression());
+  if (callee === null) {
+    return reads;
+  }
+  call.getArguments().forEach((passed, at) => {
+    const literal = literalBehind(passed);
+    if (literal === null || literal.length === 0) {
+      return;
+    }
+    const read = parameterReachesEnvRead(callee, at);
+    if (read !== null) {
+      reads.push({ name: literal, defaulted: read.defaulted, node: call });
+    }
+  });
+  return reads;
+}
+function functionBehindCallee(callee) {
+  const nameNode = N.isPropertyAccessExpression(callee) ? callee.getNameNode() : callee;
+  if (!N.isIdentifier(nameNode)) {
+    return null;
+  }
+  for (const definition of nameNode.getDefinitionNodes()) {
+    if (N.isFunctionDeclaration(definition) || N.isMethodDeclaration(definition)) {
+      return definition;
+    }
+    if (N.isVariableDeclaration(definition)) {
+      const initializer = definition.getInitializer();
+      if (initializer !== void 0 && (N.isArrowFunction(initializer) || N.isFunctionExpression(initializer))) {
+        return initializer;
+      }
+    }
+  }
+  return null;
+}
+var PARAM_ENV_READS = /* @__PURE__ */ new WeakMap();
+function parameterReachesEnvRead(fn, at) {
+  const byParameter = PARAM_ENV_READS.get(fn.compilerNode) ?? /* @__PURE__ */ new Map();
+  PARAM_ENV_READS.set(fn.compilerNode, byParameter);
+  const remembered = byParameter.get(at);
+  if (remembered !== void 0) {
+    return remembered;
+  }
+  let found = null;
+  const pending = [{ fn, at }];
+  const taken = /* @__PURE__ */ new Set();
+  while (pending.length > 0 && found === null) {
+    const wanted = pending.pop();
+    const key = `${wanted.fn.getPos()}:${wanted.at}`;
+    if (taken.has(key)) {
+      continue;
+    }
+    taken.add(key);
+    const parameter = wanted.fn.getParameters()[wanted.at];
+    if (parameter === void 0) {
+      continue;
+    }
+    const name = parameter.getName();
+    wanted.fn.forEachDescendant((node) => {
+      if (found !== null) {
+        return;
+      }
+      if (N.isElementAccessExpression(node) && isProcessEnv(node.getExpression())) {
+        const argument = node.getArgumentExpression();
+        if (argument !== void 0 && argument.getText() === name) {
+          found = { defaulted: isDefaultedAt(node) };
+        }
+        return;
+      }
+      if (N.isCallExpression(node)) {
+        node.getArguments().forEach((argument, position) => {
+          if (!N.isIdentifier(argument) || argument.getText() !== name) {
+            return;
+          }
+          const next = functionBehindCallee(node.getExpression());
+          if (next !== null && next !== wanted.fn) {
+            pending.push({ fn: next, at: position });
+          }
+        });
+      }
+    });
+  }
+  byParameter.set(at, found);
+  return found;
+}
+function isDefaultedAt(node) {
+  let child = node;
+  let parent = child.getParent();
+  while (parent !== void 0) {
+    if (N.isParenthesizedExpression(parent)) {
+      child = parent;
+      parent = parent.getParent();
+      continue;
+    }
+    if (!N.isBinaryExpression(parent)) {
+      return false;
+    }
+    const op = parent.getOperatorToken().getText();
+    if (op !== "??" && op !== "||") {
+      return false;
+    }
+    if (parent.getLeft() === child) {
+      return true;
+    }
+    child = parent;
+    parent = parent.getParent();
+  }
+  return false;
+}
+function configReadEffect(read, deploymentTarget, instanceName) {
+  return {
+    type: "interaction",
+    binding: runtimeConfigBinding({
+      recognition: "@suss/runtime-node",
+      deploymentTarget,
+      instanceName
+    }),
+    callee: readName(read.name),
+    interaction: {
+      class: "config-read",
+      name: read.name,
+      defaulted: read.defaulted
+    }
+  };
+}
+function recognizeProcessEnvRead(access, deploymentTarget, instanceName) {
+  const reads = envReadsAt(access);
+  if (reads.length === 0) {
+    return null;
+  }
+  return reads.map(
+    (read) => configReadEffect(read, deploymentTarget, instanceName)
+  );
+}
+function envVarRecognizer(opts = {}) {
+  const deploymentTarget = opts.deploymentTarget ?? "lambda";
+  const instanceName = opts.instanceName ?? "<unknown>";
+  return (access, _ctx) => recognizeProcessEnvRead(access, deploymentTarget, instanceName);
+}
+var FILE_LOCATION_GLOBALS = /* @__PURE__ */ new Set(["__dirname", "__filename"]);
+function moduleMetaRead(callee) {
+  return {
+    type: "interaction",
+    binding: runtimeConfigBinding2({
+      recognition: "@suss/runtime-node",
+      deploymentTarget: "lambda",
+      instanceName: "<runtime>"
+    }),
+    callee,
+    interaction: {
+      class: "config-read",
+      name: callee,
+      defaulted: false
+    }
+  };
+}
+var importMetaRecognizer = (access, _ctx) => {
+  const node = access;
+  if (!Node.isPropertyAccessExpression(node)) {
+    return null;
+  }
+  const inner = node.getExpression();
+  if (!Node.isMetaProperty(inner)) {
+    return null;
+  }
+  const keyword = inner.getKeywordToken();
+  if (keyword === void 0 || inner.getNameNode().getText() !== "meta") {
+    return null;
+  }
+  return [moduleMetaRead(node.getText())];
+};
+var fileLocationRecognizer = (access, _ctx) => {
+  const node = access;
+  if (!Node.isPropertyAccessExpression(node)) {
+    return null;
+  }
+  const subject = node.getExpression();
+  if (!Node.isIdentifier(subject)) {
+    return null;
+  }
+  const text = subject.getText();
+  if (!FILE_LOCATION_GLOBALS.has(text)) {
+    return null;
+  }
+  return [moduleMetaRead(text)];
+};
+function isProcessEnvVarRead(node) {
+  const inner = node.getExpression();
+  if (!Node2.isPropertyAccessExpression(inner)) {
+    return false;
+  }
+  if (inner.getName() !== "env") {
+    return false;
+  }
+  const root = inner.getExpression();
+  return Node2.isIdentifier(root) && root.getText() === "process";
+}
+function isProcessIdentifier(node) {
+  return Node2.isIdentifier(node) && node.getText() === "process";
+}
+var OPAQUE_PROPERTY_NAMES = /* @__PURE__ */ new Set([
+  "cwd",
+  "platform",
+  "version",
+  "versions",
+  "pid",
+  "ppid",
+  "arch",
+  "execPath",
+  "execArgv"
+]);
+function makeProcessSurfaceRecognizer(opts) {
+  const deploymentTarget = opts.deploymentTarget ?? "lambda";
+  const instanceName = opts.instanceName ?? "<unknown>";
+  return (access, _ctx) => {
+    const node = access;
+    if (Node2.isPropertyAccessExpression(node)) {
+      return recognizeProperty(node, deploymentTarget, instanceName);
+    }
+    if (Node2.isElementAccessExpression(node)) {
+      return recognizeElementAccess(node, deploymentTarget, instanceName);
+    }
+    return null;
+  };
+}
+function recognizeProperty(node, deploymentTarget, instanceName) {
+  if (isProcessEnvVarRead(node)) {
+    return null;
+  }
+  const subject = node.getExpression();
+  const name = node.getName();
+  if (isProcessIdentifier(subject) && name === "argv") {
+    return [argvRead(deploymentTarget, instanceName, node.getText(), null)];
+  }
+  if (isProcessIdentifier(subject) && OPAQUE_PROPERTY_NAMES.has(name)) {
+    return [opaqueProcessRead(node.getText(), `process.${name}`)];
+  }
+  return null;
+}
+function recognizeElementAccess(node, deploymentTarget, instanceName) {
+  const subject = node.getExpression();
+  if (!Node2.isPropertyAccessExpression(subject)) {
+    return null;
+  }
+  if (subject.getName() !== "argv") {
+    return null;
+  }
+  const root = subject.getExpression();
+  if (!isProcessIdentifier(root)) {
+    return null;
+  }
+  const arg = node.getArgumentExpression();
+  let indexLabel = null;
+  if (arg !== void 0 && Node2.isNumericLiteral(arg)) {
+    indexLabel = String(arg.getLiteralValue());
+  }
+  return [argvRead(deploymentTarget, instanceName, node.getText(), indexLabel)];
+}
+function argvRead(deploymentTarget, instanceName, callee, indexLabel) {
+  const name = indexLabel !== null ? `argv[${indexLabel}]` : "argv";
+  return {
+    type: "interaction",
+    binding: runtimeConfigBinding3({
+      recognition: "@suss/runtime-node",
+      deploymentTarget,
+      instanceName
+    }),
+    callee,
+    interaction: {
+      class: "config-read",
+      name,
+      defaulted: false
+    }
+  };
+}
+function opaqueProcessRead(callee, _label) {
+  return {
+    type: "interaction",
+    binding: runtimeConfigBinding3({
+      recognition: "@suss/runtime-node",
+      deploymentTarget: "lambda",
+      instanceName: "<runtime>"
+    }),
+    callee,
+    interaction: {
+      class: "config-read",
+      name: callee,
+      defaulted: false
+    }
+  };
+}
+function processSurfaceRecognizer(opts = {}) {
+  return makeProcessSurfaceRecognizer(opts);
+}
+var PRIMITIVES = [
+  {
+    via: "setImmediate",
+    hasDelayArg: false,
+    matches: (c) => isBareIdentifierCall(c, "setImmediate")
+  },
+  {
+    via: "setTimeout",
+    hasDelayArg: true,
+    matches: (c) => isBareIdentifierCall(c, "setTimeout")
+  },
+  {
+    via: "setInterval",
+    hasDelayArg: true,
+    matches: (c) => isBareIdentifierCall(c, "setInterval")
+  },
+  {
+    via: "queueMicrotask",
+    hasDelayArg: false,
+    matches: (c) => isBareIdentifierCall(c, "queueMicrotask")
+  },
+  {
+    via: "process.nextTick",
+    hasDelayArg: false,
+    matches: (c) => isPropertyAccessCall(c, "process", "nextTick")
+  }
+];
+function isBareIdentifierCall(call, name) {
+  const callee = call.getExpression();
+  return Node3.isIdentifier(callee) && callee.getText() === name;
+}
+function isPropertyAccessCall(call, rootName, propName) {
+  const callee = call.getExpression();
+  if (!Node3.isPropertyAccessExpression(callee)) {
+    return false;
+  }
+  const pae = callee;
+  if (pae.getName() !== propName) {
+    return false;
+  }
+  const root = pae.getExpression();
+  return Node3.isIdentifier(root) && root.getText() === rootName;
+}
+function recognizePrimitive(call) {
+  for (const p of PRIMITIVES) {
+    if (p.matches(call)) {
+      return p;
+    }
+  }
+  return null;
+}
+function describeCallback(arg) {
+  if (arg === void 0) {
+    return { type: "opaque", reason: "missing-callback-argument" };
+  }
+  if (Node3.isArrowFunction(arg) || Node3.isFunctionExpression(arg)) {
+    return { type: "literal" };
+  }
+  if (Node3.isIdentifier(arg)) {
+    return { type: "identifier", name: arg.getText() };
+  }
+  return { type: "opaque", reason: "non-literal-callback" };
+}
+var schedulingRecognizer = (call, _ctx) => {
+  const c = call;
+  if (!Node3.isCallExpression(c)) {
+    return null;
+  }
+  const primitive = recognizePrimitive(c);
+  if (primitive === null) {
+    return null;
+  }
+  const callback = describeCallback(c.getArguments()[0]);
+  const callbackRef = callback.type === "literal" ? { type: "literal" } : callback.type === "identifier" ? { type: "identifier", name: callback.name ?? "<unknown>" } : {
+    type: "opaque",
+    reason: callback.reason ?? "non-literal-callback"
+  };
+  const effect = {
+    type: "interaction",
+    binding: functionCallBinding({
+      transport: "in-process",
+      recognition: "@suss/runtime-node"
+    }),
+    callee: c.getExpression().getText(),
+    interaction: {
+      class: "schedule",
+      via: primitive.via,
+      callbackRef,
+      hasDelay: primitive.hasDelayArg && c.getArguments().length >= 2
+    }
+  };
+  return [effect];
+};
+var SCHEDULED_CALLBACK_INPUT = {
+  type: "positionalParams",
+  // Timer callbacks receive whatever `...args` were passed at the
+  // schedule site. v0 doesn't track these positions individually,
+  // packs that need argument-shape modeling can layer it on top.
+  params: []
+};
+function nodeSchedulingSubUnits(parent, _ctx) {
+  const parentFunc = parent.func;
+  const out = [];
+  const counters = /* @__PURE__ */ new Map();
+  parentFunc.forEachDescendant((node, traversal) => {
+    if (node !== parentFunc && (Node3.isFunctionDeclaration(node) || Node3.isFunctionExpression(node) || Node3.isArrowFunction(node) || Node3.isMethodDeclaration(node))) {
+      traversal.skip();
+      return;
+    }
+    if (!Node3.isCallExpression(node)) {
+      return;
+    }
+    const primitive = recognizePrimitive(node);
+    if (primitive === null) {
+      return;
+    }
+    const arg = node.getArguments()[0];
+    if (arg === void 0 || !(Node3.isArrowFunction(arg) || Node3.isFunctionExpression(arg))) {
+      return;
+    }
+    const idx = counters.get(primitive.via) ?? 0;
+    counters.set(primitive.via, idx + 1);
+    out.push({
+      func: arg,
+      kind: "scheduled-callback",
+      // Naming convention: `<parent>.<via>#<index>`. Multiple
+      // setImmediate calls in the same parent get distinct indices.
+      name: `${parent.name}.${primitive.via}#${idx}`,
+      inputMapping: SCHEDULED_CALLBACK_INPUT,
+      metadata: {
+        node: {
+          schedulingPrimitive: primitive.via
+        }
+      }
+    });
+  });
+  return out;
+}
+var PACK_VERSION = "0.1.0";
+function nodeRuntimePack(options = {}) {
+  const configOptions = {
+    ...options.deploymentTarget !== void 0 ? { deploymentTarget: options.deploymentTarget } : {},
+    ...options.instanceName !== void 0 ? { instanceName: options.instanceName } : {}
+  };
+  const processRecognizer = processSurfaceRecognizer(configOptions);
+  const envRecognizer = envVarRecognizer(configOptions);
+  return {
+    name: "node",
+    version: PACK_VERSION,
+    protocol: "in-process",
+    languages: ["typescript", "javascript"],
+    discovery: [],
+    terminals: [],
+    inputMapping: { type: "positionalParams", params: [] },
+    invocationRecognizers: [schedulingRecognizer],
+    accessRecognizers: [
+      // `envRecognizer` owns `process.env.X`; `processRecognizer`
+      // owns the rest of the process surface and skips env reads,
+      // together they partition `process.*` without duplication.
+      envRecognizer,
+      processRecognizer,
+      importMetaRecognizer,
+      fileLocationRecognizer
+    ],
+    subUnits: nodeSchedulingSubUnits
+  };
+}
+var index_default = nodeRuntimePack;
+export {
+  index_default as default
+};

package/dist/prisma.d.ts

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