@nocobase/plugin-flow-engine 2.1.0-beta.42 → 2.1.0-beta.44

package/dist/server/flow-surfaces/runjs-authoring/runtime/errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowSurfaceErrorItemInput } from '../../errors';
+import type { RunJsAuthoringRepairClass } from '../types';
+export declare function buildRunJsAuthoringError(input: {
+    path: string;
+    repairClass: RunJsAuthoringRepairClass;
+    message: string;
+    modelUse?: string;
+    surface?: string;
+    index: number;
+    source: string;
+    ruleId?: string;
+    details?: Record<string, any>;
+}): FlowSurfaceErrorItemInput;
+export declare function dedupeErrors(errors: FlowSurfaceErrorItemInput[]): FlowSurfaceErrorItemInput[];

package/dist/server/flow-surfaces/runjs-authoring/runtime/errors.js

@@ -0,0 +1,91 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  buildRunJsAuthoringError: () => buildRunJsAuthoringError,
+  dedupeErrors: () => dedupeErrors
+});
+module.exports = __toCommonJS(errors_exports);
+var import_rules = require("../rules");
+var import_constants = require("./constants");
+function buildRunJsAuthoringError(input) {
+  const rule = (0, import_rules.getRunJsAuthoringRule)(input.repairClass);
+  const loc = getLineColumn(input.source, input.index);
+  const agentInstruction = getRunJsAuthoringAgentInstruction(input.repairClass);
+  return {
+    path: input.path,
+    ruleId: input.ruleId || rule.defaultRuleId,
+    message: buildRunJsAuthoringErrorMessage(input.message, agentInstruction, rule.suggestedAction),
+    details: buildDefinedDetails({
+      repairClass: input.repairClass,
+      suggestedAction: rule.suggestedAction,
+      skipForbidden: true,
+      mustRetry: true,
+      agentInstruction,
+      line: loc.line,
+      column: loc.column,
+      ...input.details
+    })
+  };
+}
+function getRunJsAuthoringAgentInstruction(repairClass) {
+  return import_constants.CONTEXT_FIRST_REPAIR_CLASSES.has(repairClass) ? import_constants.RUNJS_CONTEXT_AND_RETRY_INSTRUCTION : import_constants.RUNJS_FIX_AND_RETRY_INSTRUCTION;
+}
+function buildRunJsAuthoringErrorMessage(message, agentInstruction, suggestedAction) {
+  return [message, agentInstruction, suggestedAction ? `Suggested fix: ${suggestedAction}` : ""].filter(Boolean).join(" ");
+}
+function buildDefinedDetails(details) {
+  return Object.fromEntries(
+    Object.entries(details).filter(([, value]) => typeof value !== "undefined" && value !== "")
+  );
+}
+function getLineColumn(source, index) {
+  const safeIndex = Math.max(0, Math.min(index, source.length));
+  const prefix = source.slice(0, safeIndex);
+  const lines = prefix.split(/\r\n|\r|\n/);
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1].length + 1
+  };
+}
+function dedupeErrors(errors) {
+  const seen = /* @__PURE__ */ new Set();
+  return errors.filter((error) => {
+    var _a, _b;
+    const key = `${error.path}:${error.ruleId}:${(_a = error.details) == null ? void 0 : _a.line}:${(_b = error.details) == null ? void 0 : _b.column}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRunJsAuthoringError,
+  dedupeErrors
+});

package/dist/server/flow-surfaces/runjs-authoring/runtime/source-budget.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowSurfaceErrorItemInput } from '../../errors';
+import type { RunJsAuthoringInspectionInput } from '../types';
+import type { RunJsSourceBudget } from '../internal-types';
+export declare function createRunJsSourceBudget(): RunJsSourceBudget;
+export declare function collectRunJsSourceLimitErrors(input: RunJsAuthoringInspectionInput, budget?: RunJsSourceBudget): {
+    errors: FlowSurfaceErrorItemInput[];
+    skipInspection: boolean;
+};

package/dist/server/flow-surfaces/runjs-authoring/runtime/source-budget.js

@@ -0,0 +1,115 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var source_budget_exports = {};
+__export(source_budget_exports, {
+  collectRunJsSourceLimitErrors: () => collectRunJsSourceLimitErrors,
+  createRunJsSourceBudget: () => createRunJsSourceBudget
+});
+module.exports = __toCommonJS(source_budget_exports);
+var import_constants = require("./constants");
+var import_errors = require("./errors");
+function createRunJsSourceBudget() {
+  return {
+    count: 0,
+    totalLength: 0
+  };
+}
+function collectRunJsSourceLimitErrors(input, budget) {
+  const source = String(input.code || "");
+  const sourceLength = source.length;
+  const modelUse = normalizeText(input.modelUse);
+  const surface = normalizeText(input.surface);
+  const errors = [];
+  if (budget) {
+    budget.count += 1;
+    budget.totalLength += sourceLength;
+  }
+  const pushLimitError = (ruleId, message, details) => {
+    errors.push(
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: "source-limit-stop",
+        ruleId,
+        message,
+        modelUse,
+        surface,
+        index: 0,
+        source,
+        details
+      })
+    );
+  };
+  const sourceTooLarge = sourceLength > import_constants.MAX_RUNJS_SOURCE_LENGTH;
+  if (sourceTooLarge && (!budget || budget.count <= import_constants.MAX_RUNJS_SOURCES_PER_REQUEST)) {
+    pushLimitError(
+      "runjs-source-too-large",
+      `flowSurfaces authoring ${input.path} RunJS source is too large to validate safely`,
+      {
+        maxSourceLength: import_constants.MAX_RUNJS_SOURCE_LENGTH,
+        sourceLength
+      }
+    );
+  }
+  let requestLimitExceeded = false;
+  if (budget && budget.count > import_constants.MAX_RUNJS_SOURCES_PER_REQUEST) {
+    requestLimitExceeded = true;
+    if (!budget.countLimitReported) {
+      budget.countLimitReported = true;
+      pushLimitError(
+        "runjs-too-many-sources",
+        `flowSurfaces authoring request contains too many RunJS sources to validate safely`,
+        {
+          maxSources: import_constants.MAX_RUNJS_SOURCES_PER_REQUEST,
+          sourceCount: budget.count
+        }
+      );
+    }
+  }
+  if (budget && budget.totalLength > import_constants.MAX_RUNJS_TOTAL_SOURCE_LENGTH) {
+    requestLimitExceeded = true;
+    if (!budget.totalLimitReported) {
+      budget.totalLimitReported = true;
+      pushLimitError(
+        "runjs-total-source-too-large",
+        `flowSurfaces authoring request contains too much RunJS source to validate safely`,
+        {
+          maxTotalSourceLength: import_constants.MAX_RUNJS_TOTAL_SOURCE_LENGTH,
+          totalSourceLength: budget.totalLength
+        }
+      );
+    }
+  }
+  return { errors, skipInspection: sourceTooLarge || requestLimitExceeded };
+}
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectRunJsSourceLimitErrors,
+  createRunJsSourceBudget
+});

package/dist/server/flow-surfaces/runjs-authoring/runtime/surface.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { RunJsAuthoringContext } from '../internal-types';
+import type { RunJsAuthoringInspectionInput, RunJsAuthoringSurfaceStyle } from '../types';
+export declare function resolveFieldModelUse(type: string, renderer: string, blockType: string): "" | "JSFieldModel" | "JSEditableFieldModel" | "JSColumnModel" | "JSItemModel";
+export declare function resolveActionModelUse(actionType: string, blockType: string, slot: 'actions' | 'recordActions'): "" | "JSCollectionActionModel" | "JSRecordActionModel" | "JSFormActionModel" | "JSItemActionModel" | "FilterFormJSActionModel" | "JSActionModel";
+export declare function resolveConfigureModelUse(currentNode: any): string;
+export declare function resolveConfigureBlockType(context: RunJsAuthoringContext): string;
+export declare function resolvePublicBlockType(value: any): string;
+export declare function resolveSurfaceStyle(input: RunJsAuthoringInspectionInput): RunJsAuthoringSurfaceStyle | undefined;
+export declare function resolveModelSurfaceStyle(modelUse: any): RunJsAuthoringSurfaceStyle | undefined;
+export declare function normalizeActionType(value: any): string;
+export declare function normalizeText(value: any): string;

package/dist/server/flow-surfaces/runjs-authoring/runtime/surface.js

@@ -0,0 +1,140 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var surface_exports = {};
+__export(surface_exports, {
+  normalizeActionType: () => normalizeActionType,
+  normalizeText: () => normalizeText,
+  resolveActionModelUse: () => resolveActionModelUse,
+  resolveConfigureBlockType: () => resolveConfigureBlockType,
+  resolveConfigureModelUse: () => resolveConfigureModelUse,
+  resolveFieldModelUse: () => resolveFieldModelUse,
+  resolveModelSurfaceStyle: () => resolveModelSurfaceStyle,
+  resolvePublicBlockType: () => resolvePublicBlockType,
+  resolveSurfaceStyle: () => resolveSurfaceStyle
+});
+module.exports = __toCommonJS(surface_exports);
+var import_constants = require("./constants");
+function resolveFieldModelUse(type, renderer, blockType) {
+  if (type === "jsColumn") {
+    return "JSColumnModel";
+  }
+  if (type === "jsItem") {
+    return "JSItemModel";
+  }
+  if (renderer === "js") {
+    return ["createForm", "editForm"].includes(blockType) ? "JSEditableFieldModel" : "JSFieldModel";
+  }
+  return "";
+}
+function resolveActionModelUse(actionType, blockType, slot) {
+  if (actionType === "jsItem") {
+    return "JSItemActionModel";
+  }
+  if (actionType !== "js") {
+    return "";
+  }
+  if (slot === "recordActions") {
+    return "JSRecordActionModel";
+  }
+  if (["createForm", "editForm"].includes(blockType)) {
+    return "JSFormActionModel";
+  }
+  if (blockType === "filterForm") {
+    return "FilterFormJSActionModel";
+  }
+  if (["table", "list", "gridCard", "calendar", "kanban"].includes(blockType)) {
+    return "JSCollectionActionModel";
+  }
+  return "JSActionModel";
+}
+function resolveConfigureModelUse(currentNode) {
+  var _a, _b;
+  const currentUse = normalizeText(currentNode == null ? void 0 : currentNode.use);
+  if (import_constants.KNOWN_MODEL_USES.has(currentUse)) {
+    return currentUse;
+  }
+  const fieldUse = normalizeText((_b = (_a = currentNode == null ? void 0 : currentNode.subModels) == null ? void 0 : _a.field) == null ? void 0 : _b.use);
+  if (import_constants.KNOWN_MODEL_USES.has(fieldUse)) {
+    return fieldUse;
+  }
+  return "";
+}
+function resolveConfigureBlockType(context) {
+  var _a;
+  const hostBlockType = normalizeText(context.hostBlockType);
+  if (hostBlockType) {
+    return resolvePublicBlockType(hostBlockType);
+  }
+  const currentUse = normalizeText((_a = context.currentNode) == null ? void 0 : _a.use);
+  return resolvePublicBlockType(currentUse);
+}
+function resolvePublicBlockType(value) {
+  const normalized = normalizeText(value);
+  return import_constants.PUBLIC_BLOCK_TYPE_BY_MODEL_USE[normalized] || normalized;
+}
+function resolveSurfaceStyle(input) {
+  if (input.surfaceStyle) {
+    return input.surfaceStyle;
+  }
+  const surface = normalizeText(input.surface);
+  if (surface && import_constants.SURFACE_STYLE_BY_ID[surface]) {
+    return import_constants.SURFACE_STYLE_BY_ID[surface];
+  }
+  return resolveModelSurfaceStyle(input.modelUse);
+}
+function resolveModelSurfaceStyle(modelUse) {
+  const normalized = normalizeText(modelUse);
+  if (import_constants.RENDER_MODEL_USES.has(normalized)) {
+    return "render";
+  }
+  if (import_constants.ACTION_MODEL_USES.has(normalized)) {
+    return "action";
+  }
+  if (import_constants.VALUE_MODEL_USES.has(normalized)) {
+    return "value";
+  }
+  return void 0;
+}
+function normalizeActionType(value) {
+  const normalized = normalizeText(value);
+  return import_constants.ACTION_TYPE_ALIASES.get(normalized.toLowerCase()) || normalized;
+}
+function normalizeText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeActionType,
+  normalizeText,
+  resolveActionModelUse,
+  resolveConfigureBlockType,
+  resolveConfigureModelUse,
+  resolveFieldModelUse,
+  resolveModelSurfaceStyle,
+  resolvePublicBlockType,
+  resolveSurfaceStyle
+});

package/dist/server/flow-surfaces/runjs-authoring/runtime/types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { FlowSurfaceErrorItemInput } from '../../errors';
+import type { CtxLibMemberCaseMismatch, InvalidCtxLibMemberAccess, InvalidReactRuntimeBinding, ResourceCallInReactHook, RunJsAstInspection, RunJsAuthoringContext, SourceBinding, SourceRange } from '../internal-types';
+import type { RunJsAuthoringInspectionInput, RunJsAuthoringSurfaceStyle } from '../types';
+type IndexedEntry = {
+    index: number;
+};
+type CapabilityEntry = IndexedEntry & {
+    capability: string;
+};
+export type RunJsScanResult = RunJsAstInspection & {
+    blockRanges: SourceRange[];
+    ctxAliases: Array<{
+        alias: string;
+        index: number;
+    }>;
+    ctxLibMemberCaseMismatches: CtxLibMemberCaseMismatch[];
+    ctxMemberAccesses: Array<{
+        index: number;
+        member: string;
+    }>;
+    ctxRenderCalls: IndexedEntry[];
+    ctxRenderComponentSignatureCalls: Array<CapabilityEntry & {
+        component: string;
+    }>;
+    ctxRequestCalls: IndexedEntry[];
+    ctxRunjsCalls: IndexedEntry[];
+    directDomAliases: Array<{
+        alias: string;
+        index: number;
+    }>;
+    directDomWrites: Array<IndexedEntry & {
+        match: string;
+    }>;
+    dynamicCtxAccesses: IndexedEntry[];
+    forbiddenBareGlobals: Array<IndexedEntry & {
+        name: string;
+    }>;
+    functionRanges: SourceRange[];
+    invalidCtxLibMemberAccesses: InvalidCtxLibMemberAccess[];
+    invalidReactRuntimeBindings: InvalidReactRuntimeBinding[];
+    isTopLevelFunctionWrapper: boolean;
+    masked: string;
+    reactComponentFunctionCalls: Array<CapabilityEntry & {
+        component: string;
+    }>;
+    reactComponentPropReferences: Array<CapabilityEntry & {
+        component: string;
+        prop: string;
+    }>;
+    resourceCallsInReactHooks: ResourceCallInReactHook[];
+    source: string;
+    sourceBindings: SourceBinding[];
+    topLevelCtxRenderCalls: IndexedEntry[];
+    topLevelReactHookCalls: Array<IndexedEntry & {
+        hook: string;
+        match: string;
+    }>;
+    topLevelReturns: IndexedEntry[];
+    unboundReactCreateElementCalls: IndexedEntry[];
+    windowDocumentNavigatorAliases: Array<{
+        alias: string;
+        index: number;
+        root: string;
+    }>;
+    windowDocumentNavigatorUses: Array<IndexedEntry & {
+        member: string;
+        root: string;
+    }>;
+};
+export type RunJsInspectionRuntime = {
+    context: RunJsAuthoringContext;
+    input: RunJsAuthoringInspectionInput;
+    modelUse: string;
+    scan: RunJsScanResult;
+    source: string;
+    surface: string;
+    surfaceStyle: RunJsAuthoringSurfaceStyle;
+};
+export type RunJsInspectionValidator = {
+    id: string;
+    validate(runtime: RunJsInspectionRuntime): FlowSurfaceErrorItemInput[];
+};
+export {};

package/dist/server/flow-surfaces/runjs-authoring/runtime/types.js

@@ -0,0 +1,24 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/flow-surfaces/runjs-authoring/scan/ctx-api.d.ts

@@ -0,0 +1,138 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type { AstIdentifierBinding, AstIdentifierWrite, CtxApiAlias, CtxApiCapability, CtxApiResourceAliases, CtxApiResourceHandleAlias, CtxApiResourceMethodAlias, CtxLibAlias, CtxLibsRootAlias, CtxMethodAlias, CtxNonFunctionRootAlias, CtxRootAlias, RunJsAstInspection, StaticFilterValueBinding, StaticStringBinding } from '../internal-types';
+export declare function collectCtxRootAliasesFromAst(ast: any, source: string, identifierBindings: AstIdentifierBinding[]): CtxRootAlias[];
+export declare function collectCtxDefiniteRootAliasesFromAst(ast: any, source: string, identifierBindings: AstIdentifierBinding[]): CtxRootAlias[];
+export declare function collectCtxNonFunctionRootAliasesFromAst(ast: any, source: string, ctxRootAliases: CtxRootAlias[], identifierBindings: AstIdentifierBinding[], modelUse?: string): CtxNonFunctionRootAlias[];
+export declare function collectAstInvalidCtxNonFunctionCall(node: any, ctxRootAliases: CtxRootAlias[], ctxNonFunctionRootAliases: CtxNonFunctionRootAlias[], identifierBindings: AstIdentifierBinding[], modelUse?: string): RunJsAstInspection['invalidCtxNonFunctionCalls'];
+export declare function collectCtxMethodAliasesFromAst(ast: any, source: string, identifierBindings: AstIdentifierBinding[]): CtxMethodAlias[];
+export declare function collectCtxApiAliasesFromAst(ast: any, source: string, identifierBindings: AstIdentifierBinding[]): CtxApiAlias[];
+export declare function collectCtxApiObjectPatternAliases(pattern: any, capability: CtxApiCapability | '', addAlias: (name: string, capability: CtxApiCapability, node?: any) => void): void;
+export declare function trimCtxApiAliasesAfterWrites(aliases: CtxApiAlias[], writes: AstIdentifierWrite[], identifierBindings: AstIdentifierBinding[]): CtxApiAlias[];
+export declare function collectCtxLibsRootAliasesFromAst(ast: any, source: string, identifierBindings: AstIdentifierBinding[]): CtxLibsRootAlias[];
+export declare function collectCtxLibAliasesFromAst(ast: any, source: string, rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[]): CtxLibAlias[];
+export declare function collectCtxLibObjectPatternAliases(pattern: any, sourceNode: any, rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[], addAlias: (name: string, alias: {
+    capability: string;
+    library: string;
+}, node?: any) => void): void;
+export declare function collectCtxApiResourceAliasesFromAst(ast: any, source: string, ctxApiAliases: CtxApiAlias[], stringBindings: StaticStringBinding[], staticFilterValueBindings: StaticFilterValueBinding[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceAliases;
+export declare function collectAstInvalidApiResourceCall(node: any, aliases: CtxApiAlias[], resourceAliases: CtxApiResourceAliases, source: string, identifierBindings: AstIdentifierBinding[]): RunJsAstInspection['invalidApiResourceCalls'];
+export declare function getCtxApiResourceChainedMethodFromAst(node: any, aliases: CtxApiAlias[], resourceAliases: CtxApiResourceAliases, source: string, identifierBindings: AstIdentifierBinding[]): RunJsAstInspection['invalidApiResourceCalls'][number] | undefined;
+export declare function getWrappedCtxApiResourceChainedMethodFromAst(node: any, aliases: CtxApiAlias[], resourceAliases: CtxApiResourceAliases, source: string, identifierBindings: AstIdentifierBinding[]): RunJsAstInspection['invalidApiResourceCalls'][number] | undefined;
+export declare function getCtxApiResourceHandleAliasFromAst(node: any, aliases: CtxApiResourceHandleAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceHandleAlias | undefined;
+export declare function getCtxApiResourceMethodAliasFromAst(node: any, aliases: CtxApiResourceMethodAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceMethodAlias | undefined;
+export declare function getMaybeCtxApiResourceHandleAliasFromAst(node: any, aliases: CtxApiResourceHandleAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceHandleAlias | undefined;
+export declare function collectMaybeCtxApiResourceHandleAliasesFromAst(node: any, aliases: CtxApiResourceHandleAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceHandleAlias[];
+export declare function getUniqueCtxApiResourceHandleAlias(aliases: CtxApiResourceHandleAlias[]): CtxApiResourceHandleAlias;
+export declare function getCtxApiResourceHandleAliasIdentity(alias: CtxApiResourceHandleAlias): string;
+export declare function getMaybeCtxApiResourceMethodAliasFromAst(node: any, aliases: CtxApiResourceMethodAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiResourceMethodAlias | undefined;
+export declare function getCtxApiResourceCallFromAst(node: any, aliases: CtxApiAlias[], source: string, identifierBindings: AstIdentifierBinding[]): {
+    args: any[];
+    calleeSource: string;
+    index: number;
+} | undefined;
+export declare function getCtxApiResourceCalleeFromAst(node: any, aliases: CtxApiAlias[], source: string, identifierBindings: AstIdentifierBinding[]): {
+    index: number;
+    source: string;
+} | undefined;
+export declare function getMaybeCtxApiResourceCallFromAst(node: any, aliases: CtxApiAlias[], source: string, identifierBindings: AstIdentifierBinding[]): {
+    args: any[];
+    calleeSource: string;
+    index: number;
+} | undefined;
+export declare function collectMaybeCtxApiResourceCallsFromAst(node: any, aliases: CtxApiAlias[], source: string, identifierBindings: AstIdentifierBinding[]): Array<{
+    args: any[];
+    calleeSource: string;
+    index: number;
+}>;
+export declare function getUniqueCtxApiResourceCall(calls: Array<{
+    args: any[];
+    calleeSource: string;
+    index: number;
+}>, source: string): {
+    args: any[];
+    calleeSource: string;
+    index: number;
+};
+export declare function getCtxApiResourceCallIdentity(call: {
+    args: any[];
+    calleeSource: string;
+    index: number;
+}, source: string): string;
+export declare function filterInvalidCtxApiMemberAccessesForResourceCalls(memberAccesses: RunJsAstInspection['invalidCtxApiMemberAccesses'], resourceCalls: RunJsAstInspection['invalidApiResourceCalls']): RunJsAstInspection['invalidCtxApiMemberAccesses'];
+export declare function isCtxApiResourcePath(path: ReturnType<typeof getCtxApiMemberPathFromAst>): path is NonNullable<ReturnType<typeof getCtxApiMemberPathFromAst>>;
+export declare function collectAstInvalidCtxLibPatternAccesses(ast: any, aliases: CtxLibAlias[], rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[], source: string): RunJsAstInspection['invalidCtxLibMemberAccesses'];
+export declare function collectInvalidCtxLibObjectPatternAccesses(pattern: any, sourcePath: NonNullable<ReturnType<typeof getCtxLibMemberPathFromAst>>): RunJsAstInspection['invalidCtxLibMemberAccesses'];
+export declare function collectAstInvalidCtxLibMemberAccess(node: any, aliases: CtxLibAlias[], rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[], source: string): RunJsAstInspection['invalidCtxLibMemberAccesses'][number] | undefined;
+export declare function buildInvalidCtxLibMemberAccess(path: {
+    library: string;
+    members: Array<{
+        accessKind: 'bracket' | 'destructure' | 'member';
+        index: number;
+        name: string;
+    }>;
+    rootCapability: string;
+}): RunJsAstInspection['invalidCtxLibMemberAccesses'][number] | undefined;
+export declare function getCtxLibMemberCapability(rootCapability: string, member: {
+    accessKind: 'bracket' | 'destructure' | 'member';
+    name: string;
+}): string;
+export declare function getSuggestedCtxLibMemberImport(library: string, member: string): string;
+export declare function getCtxLibMemberPathFromAst(node: any, aliases: CtxLibAlias[], rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[], source: string): {
+    dynamicIndex: number;
+    hasDynamicMember: boolean;
+    library: string;
+    libraryIndex: number;
+    memberIndex: number;
+    members: Array<{
+        accessKind: 'bracket' | 'destructure' | 'member';
+        index: number;
+        name: string;
+    }>;
+    rootCapability: string;
+} | undefined;
+export declare function getDirectCtxLibPathFromAst(node: any, rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[], source: string): ReturnType<typeof getCtxLibMemberPathFromAst>;
+export declare function isCtxLibsRootFromAst(node: any, rootAliases: CtxLibsRootAlias[], identifierBindings: AstIdentifierBinding[]): boolean;
+export declare function collectAstInvalidCtxApiPatternAccesses(ast: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): RunJsAstInspection['invalidCtxApiMemberAccesses'];
+export declare function getCtxApiCapabilityMemberPrefix(capability: CtxApiAlias['capability']): string[];
+export declare function collectInvalidCtxApiObjectPatternAccesses(pattern: any, prefix: string[]): RunJsAstInspection['invalidCtxApiMemberAccesses'];
+export declare function collectAstInvalidCtxApiMemberAccess(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[], source: string): RunJsAstInspection['invalidCtxApiMemberAccesses'][number] | undefined;
+export declare function buildInvalidCtxApiMemberAccess(memberPath: string[], index: number, hasDynamicMember?: boolean): RunJsAstInspection['invalidCtxApiMemberAccesses'][number] | undefined;
+export declare function collectAstInvalidCtxApiReadonlyWrites(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): RunJsAstInspection['invalidCtxApiMemberAccesses'];
+export declare function collectAstWriteTargetNodes(node: any, visit: (node: any) => void): void;
+export declare function getCtxApiMemberAccessFromAst(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): {
+    dynamicIndex: number;
+    hasDynamicMember: boolean;
+    memberIndex: number;
+    memberPath: string[];
+} | undefined;
+export declare function getCtxApiMemberPathFromAst(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): {
+    dynamicIndex: number;
+    hasDynamicMember: boolean;
+    isCtxApi: true;
+    memberIndex: number;
+    members: Array<{
+        index: number;
+        name: string;
+    }>;
+} | undefined;
+export declare function getCtxApiAliasMemberPath(alias: CtxApiAlias, index: number): Array<{
+    index: number;
+    name: string;
+}>;
+export declare function getCtxApiCapabilityMemberPath(capability: CtxApiAlias['capability'], index: number): Array<{
+    index: number;
+    name: string;
+}>;
+export declare function getCtxApiCapabilityFromAst(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiAlias['capability'] | '';
+export declare function getMaybeCtxApiCapabilityFromAst(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiAlias['capability'] | '';
+export declare function collectPossibleCtxApiCapabilitiesFromAst(node: any, aliases: CtxApiAlias[], identifierBindings: AstIdentifierBinding[]): CtxApiAlias['capability'][];
+export declare function selectCtxApiCapability(capabilities: CtxApiAlias['capability'][]): CtxApiAlias['capability'] | '';
+export declare function uniqueCtxApiCapabilities(capabilities: Array<CtxApiAlias['capability'] | ''>): CtxApiAlias['capability'][];
+export declare function isCtxApiCapabilityDefinitelyTruthy(capability: CtxApiAlias['capability']): boolean;