@vibes.diy/api-svc 14.3.20 → 14.3.22

package/intern/opens-check.js

@@ -0,0 +1,1044 @@
+import { exception2Result } from "@adviser/cement";
+import { Parser } from "acorn";
+import acornJsx from "acorn-jsx";
+import { transform } from "sucrase";
+import { lockedGroupsVersions } from "./grouped-vibe-import-map.js";
+export const OPENS_ADVISORY_CLASSES = new Set(["unknown-package"]);
+const LOOK_EXPORTS = [
+    "Avatar",
+    "AvatarFallback",
+    "Badge",
+    "Button",
+    "Card",
+    "CardContent",
+    "CardDescription",
+    "CardFooter",
+    "CardHeader",
+    "CardTitle",
+    "Dialog",
+    "DialogContent",
+    "DialogDescription",
+    "DialogFooter",
+    "DialogHeader",
+    "DialogTitle",
+    "DialogTrigger",
+    "DropdownMenu",
+    "DropdownMenuContent",
+    "DropdownMenuItem",
+    "DropdownMenuTrigger",
+    "Input",
+    "LOOK_CLASS_CANDIDATES",
+    "Label",
+    "Popover",
+    "PopoverContent",
+    "PopoverTrigger",
+    "Progress",
+    "Select",
+    "SelectContent",
+    "SelectItem",
+    "SelectTrigger",
+    "SelectValue",
+    "Separator",
+    "Sheet",
+    "SheetContent",
+    "SheetDescription",
+    "SheetFooter",
+    "SheetHeader",
+    "SheetTitle",
+    "SheetTrigger",
+    "Skeleton",
+    "Table",
+    "TableBody",
+    "TableCell",
+    "TableHead",
+    "TableHeader",
+    "TableRow",
+    "Tabs",
+    "TabsContent",
+    "TabsList",
+    "TabsTrigger",
+    "Textarea",
+    "Tooltip",
+    "TooltipContent",
+    "TooltipProvider",
+    "TooltipTrigger",
+    "cn",
+];
+const LOOK_OVERLAY_EXPORTS = [
+    "Dialog",
+    "DialogContent",
+    "DialogDescription",
+    "DialogFooter",
+    "DialogHeader",
+    "DialogTitle",
+    "DialogTrigger",
+    "DropdownMenu",
+    "DropdownMenuContent",
+    "DropdownMenuItem",
+    "DropdownMenuTrigger",
+    "Popover",
+    "PopoverContent",
+    "PopoverTrigger",
+    "Select",
+    "SelectContent",
+    "SelectItem",
+    "SelectTrigger",
+    "SelectValue",
+    "Sheet",
+    "SheetContent",
+    "SheetDescription",
+    "SheetFooter",
+    "SheetHeader",
+    "SheetTitle",
+    "SheetTrigger",
+    "Tooltip",
+    "TooltipContent",
+    "TooltipProvider",
+    "TooltipTrigger",
+];
+const REACT_EXPORTS = [
+    "Activity",
+    "Children",
+    "Component",
+    "Fragment",
+    "Profiler",
+    "PureComponent",
+    "StrictMode",
+    "Suspense",
+    "__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE",
+    "__COMPILER_RUNTIME",
+    "act",
+    "cache",
+    "cacheSignal",
+    "captureOwnerStack",
+    "cloneElement",
+    "createContext",
+    "createElement",
+    "createRef",
+    "default",
+    "forwardRef",
+    "isValidElement",
+    "lazy",
+    "memo",
+    "startTransition",
+    "unstable_useCacheRefresh",
+    "use",
+    "useActionState",
+    "useCallback",
+    "useContext",
+    "useDebugValue",
+    "useDeferredValue",
+    "useEffect",
+    "useEffectEvent",
+    "useId",
+    "useImperativeHandle",
+    "useInsertionEffect",
+    "useLayoutEffect",
+    "useMemo",
+    "useOptimistic",
+    "useReducer",
+    "useRef",
+    "useState",
+    "useSyncExternalStore",
+    "useTransition",
+    "version",
+];
+const RUNTIME_EXPORTS = [
+    "ANON_CALLER",
+    "CALLAI_IMAGE_MAX_EDGE",
+    "CALLAI_IMAGE_QUALITY",
+    "COLOR_OVERRIDE_STYLE_ID",
+    "CREATE_VIBE_SAFE_URL_LENGTH",
+    "CallAIImageTooLargeError",
+    "CallAIRefusalError",
+    "Database",
+    "EMBED_DOCUMENT_PARAM",
+    "FONT_IMPORT_LINK_ID",
+    "FireflyDatabase",
+    "HOST_INJECTED_IFRAME_PARAMS",
+    "HOT_SWAP_ENTRY_PATH",
+    "HandleInput",
+    "IMG_GEN_SOURCE_UNUSABLE",
+    "INTERNAL_MEDIA_DB_ACCESS",
+    "ImgGen",
+    "RUNTIME_BUILD",
+    "RUNTIME_BUILD_GLOBAL",
+    "SHADCN_THEME_COLOR_NAMES",
+    "SHADCN_THEME_INLINE_CSS",
+    "TAILWIND_REMAP_STYLE_ID",
+    "VIBES_DIY_BUILDER_URL",
+    "VibeContextProvider",
+    "VibeSandboxApi",
+    "ViewerTag",
+    "__resetCalmErrorsForTests",
+    "__resetContentHeightForTests",
+    "__resetGraceForTest",
+    "__resetInterestRegistryForTests",
+    "__resetMirrorInterestBridgeForTests",
+    "__resetPaintSignalForTests",
+    "__resetPullToRefreshForTests",
+    "__resetRegisteredAccessFnSourcesForTests",
+    "__resetRegisteredSocialChangedForTests",
+    "__resetRegisteredViewerChangedForTests",
+    "__resetRuntimeBuildAnnounceForTests",
+    "__resetUrlStateForTests",
+    "__setBootErrorParentPostMessageForTests",
+    "__setCalmWindowMsForTests",
+    "__setContentProbeForTests",
+    "__setHotSwapParentPostMessageForTests",
+    "__setRegisteredVibeApiForTests",
+    "__setReportSinkForTests",
+    "__vibeLogBufferForTests",
+    "__vibeLogIdentityForTests",
+    "aclAllows",
+    "addInterest",
+    "adoptPersistedSocialGraph",
+    "adoptPersistedViewerIdentity",
+    "announceRuntimeBuild",
+    "apiFetch",
+    "applyColorOverrideMessage",
+    "applyFontImport",
+    "armGrace",
+    "beginHotSwap",
+    "beginHotSwapRollback",
+    "beginNetworkActivity",
+    "bootstrapAccessFnSources",
+    "bootstrapViewer",
+    "buildCreateVibeUrl",
+    "callAI",
+    "callAi",
+    "canRead",
+    "canSeeDoc",
+    "canWrite",
+    "classifyAuthoritativeAnonymous",
+    "clearSocialChangedBaseline",
+    "collectRelativeImports",
+    "confirmedMediaProbe",
+    "contentHeightChanged",
+    "createHotSwapState",
+    "createVibe",
+    "decorateFiles",
+    "deviceHashFor",
+    "downscaleImageDataUrl",
+    "encodeKey",
+    "endNetworkActivity",
+    "ensureMirrorInterestBridge",
+    "entryDirBase",
+    "evaluateWrite",
+    "finishHotSwapRollback",
+    "fireproof",
+    "flushVibeLog",
+    "formatRuntimeBuild",
+    "generateTailwindRemapCss",
+    "getActiveImportMap",
+    "getActiveProps",
+    "getHotSwapBaseUrl",
+    "getRegisteredAccessFnSources",
+    "getRegisteredSocialChanged",
+    "getRegisteredVibeApi",
+    "getRegisteredViewerChanged",
+    "hasAuthoritativeViewerResolved",
+    "heldInterests",
+    "imgGen",
+    "inGroup",
+    "installCalmErrorHandlers",
+    "installPullToRefresh",
+    "isBuildCalmActive",
+    "isCurrentHotSwapAttempt",
+    "isCurrentHotSwapRollback",
+    "isEmbeddedDocumentSearch",
+    "isFromHostShell",
+    "isGraceDegraded",
+    "isHotSwapAttemptCurrent",
+    "isHotSwapRollbackCurrent",
+    "isSupersededProvisionalViewerEvt",
+    "isTrustedViewerSource",
+    "isViewerEnvPending",
+    "listDbNames",
+    "loadHotSwapTranspiler",
+    "makeClientCtx",
+    "markHotSwapApplied",
+    "measureContentHeight",
+    "mergeKnownCache",
+    "mountVibe",
+    "noteBuildActivity",
+    "noteHotSwapApplied",
+    "noteHotSwapPainted",
+    "onUncaughtVibeError",
+    "orderCompanionGraph",
+    "parseRuntimeBuild",
+    "postBootErrorToParent",
+    "postHotSwapErrorToParent",
+    "postHotSwapOkToParent",
+    "prepareCallAIPrompt",
+    "promoteHotSwap",
+    "reconcileSoftSocialGraphWithViewer",
+    "recordEnvBaselinesFromMessage",
+    "recordSocialChangedBaseline",
+    "recordSocialGraphFromEvt",
+    "recordViewerChangedBaseline",
+    "recordViewerIdentityFromEvt",
+    "registerCallAI",
+    "registerContentHeightBridge",
+    "registerDependencies",
+    "registerFirefly",
+    "registerImgGen",
+    "registerInterestSink",
+    "registerPullToRefreshHandler",
+    "registerUrlStateBridge",
+    "registerVibeLog",
+    "removeInterest",
+    "renderColorOverrideCss",
+    "renderVibeLogArgs",
+    "reportHotSwapFailure",
+    "resizeImageToBase64",
+    "resolveBuilderOrigin",
+    "resolveBuilderOriginFrom",
+    "resolveCompanionPath",
+    "rewriteBareSpecifiers",
+    "rewriteRelativeSpecifiers",
+    "rewriteRelativeSpecifiersWithBlobs",
+    "seedHotSwapBootSource",
+    "setAppContainer",
+    "setGraceMsForTest",
+    "setHotSwapRestore",
+    "setHotSwapRuntimeId",
+    "socialEnv",
+    "splitVibeLogArgs",
+    "stripHostInjectedParams",
+    "subscribeGrace",
+    "unmountVibe",
+    "unregisterVibeLog",
+    "uploadViewerAvatar",
+    "urlStateChanged",
+    "useCaptureSeedRead",
+    "useConnection",
+    "useEnv",
+    "useFireproof",
+    "useGraceDegraded",
+    "useImgGen",
+    "useInterest",
+    "useSocial",
+    "useVibe",
+    "useVibeContext",
+    "useViewer",
+    "vibe",
+    "vibeApi",
+    "vibeEnv",
+    "vibeLog",
+    "vibeMountParams",
+    "viewerEnv",
+];
+const RUNTIME_ALIAS = "alias:@vibes.diy/vibe-runtime";
+function importMapEntries() {
+    return Object.values(lockedGroupsVersions).flatMap((group) => Object.entries(group));
+}
+export const OPENS_MODULE_EXPORTS = {
+    "@vibes.diy/look": LOOK_EXPORTS,
+    "@vibes.diy/look/overlay": LOOK_OVERLAY_EXPORTS,
+    react: REACT_EXPORTS,
+    "@vibes.diy/vibe-runtime": RUNTIME_EXPORTS,
+    ...Object.fromEntries(importMapEntries().flatMap(([spec, target]) => target === RUNTIME_ALIAS ? [[spec, RUNTIME_EXPORTS]] : [])),
+};
+function isMappedSpecifier(spec) {
+    return importMapEntries().some(([key]) => key === spec || (key.endsWith("/") && spec.startsWith(key)));
+}
+const BROWSER_GLOBALS = new Set([
+    "undefined",
+    "NaN",
+    "Infinity",
+    "globalThis",
+    "arguments",
+    "eval",
+    "Object",
+    "Function",
+    "Array",
+    "String",
+    "Number",
+    "Boolean",
+    "Symbol",
+    "BigInt",
+    "Math",
+    "JSON",
+    "Date",
+    "RegExp",
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "ReferenceError",
+    "EvalError",
+    "URIError",
+    "AggregateError",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "WeakRef",
+    "FinalizationRegistry",
+    "Promise",
+    "Proxy",
+    "Reflect",
+    "Atomics",
+    "Iterator",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "DataView",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array",
+    "Intl",
+    "parseInt",
+    "parseFloat",
+    "isNaN",
+    "isFinite",
+    "encodeURI",
+    "encodeURIComponent",
+    "decodeURI",
+    "decodeURIComponent",
+    "escape",
+    "unescape",
+    "window",
+    "self",
+    "document",
+    "navigator",
+    "location",
+    "history",
+    "screen",
+    "top",
+    "parent",
+    "frames",
+    "opener",
+    "console",
+    "alert",
+    "confirm",
+    "prompt",
+    "print",
+    "open",
+    "close",
+    "focus",
+    "blur",
+    "name",
+    "status",
+    "origin",
+    "localStorage",
+    "sessionStorage",
+    "indexedDB",
+    "caches",
+    "crypto",
+    "performance",
+    "visualViewport",
+    "devicePixelRatio",
+    "innerWidth",
+    "innerHeight",
+    "outerWidth",
+    "outerHeight",
+    "scrollX",
+    "scrollY",
+    "pageXOffset",
+    "pageYOffset",
+    "scrollTo",
+    "scrollBy",
+    "scroll",
+    "matchMedia",
+    "getComputedStyle",
+    "getSelection",
+    "isSecureContext",
+    "reportError",
+    "setTimeout",
+    "clearTimeout",
+    "setInterval",
+    "clearInterval",
+    "requestAnimationFrame",
+    "cancelAnimationFrame",
+    "requestIdleCallback",
+    "cancelIdleCallback",
+    "queueMicrotask",
+    "structuredClone",
+    "atob",
+    "btoa",
+    "postMessage",
+    "addEventListener",
+    "removeEventListener",
+    "dispatchEvent",
+    "customElements",
+    "speechSynthesis",
+    "fetch",
+    "Headers",
+    "Request",
+    "Response",
+    "URL",
+    "URLSearchParams",
+    "AbortController",
+    "AbortSignal",
+    "FormData",
+    "Blob",
+    "File",
+    "FileList",
+    "FileReader",
+    "TextEncoder",
+    "TextDecoder",
+    "WebSocket",
+    "EventSource",
+    "BroadcastChannel",
+    "MessageChannel",
+    "MessagePort",
+    "Worker",
+    "SharedWorker",
+    "DOMParser",
+    "XMLSerializer",
+    "XMLHttpRequest",
+    "ReadableStream",
+    "WritableStream",
+    "TransformStream",
+    "CompressionStream",
+    "DecompressionStream",
+    "Notification",
+    "DOMException",
+    "CSS",
+    "CSSStyleSheet",
+    "Node",
+    "Element",
+    "HTMLElement",
+    "HTMLDivElement",
+    "HTMLInputElement",
+    "HTMLTextAreaElement",
+    "HTMLCanvasElement",
+    "HTMLImageElement",
+    "HTMLVideoElement",
+    "HTMLAudioElement",
+    "HTMLAnchorElement",
+    "HTMLButtonElement",
+    "HTMLFormElement",
+    "HTMLSelectElement",
+    "SVGElement",
+    "Document",
+    "DocumentFragment",
+    "Text",
+    "Range",
+    "Selection",
+    "NodeFilter",
+    "Event",
+    "CustomEvent",
+    "KeyboardEvent",
+    "MouseEvent",
+    "PointerEvent",
+    "TouchEvent",
+    "WheelEvent",
+    "InputEvent",
+    "FocusEvent",
+    "DragEvent",
+    "ClipboardEvent",
+    "EventTarget",
+    "IntersectionObserver",
+    "ResizeObserver",
+    "MutationObserver",
+    "Image",
+    "Audio",
+    "Option",
+    "OffscreenCanvas",
+    "Path2D",
+    "ImageData",
+    "ImageBitmap",
+    "createImageBitmap",
+    "CanvasRenderingContext2D",
+    "WebGLRenderingContext",
+    "WebGL2RenderingContext",
+    "DOMRect",
+    "DOMMatrix",
+    "DOMPoint",
+    "AudioContext",
+    "webkitAudioContext",
+    "OfflineAudioContext",
+    "AudioBuffer",
+    "AudioNode",
+    "AudioParam",
+    "GainNode",
+    "OscillatorNode",
+    "AnalyserNode",
+    "BiquadFilterNode",
+    "AudioBufferSourceNode",
+    "MediaRecorder",
+    "MediaStream",
+    "MediaSource",
+    "SpeechSynthesisUtterance",
+    "SpeechRecognition",
+    "webkitSpeechRecognition",
+    "Geolocation",
+]);
+function isGlobalName(name) {
+    return BROWSER_GLOBALS.has(name);
+}
+function asNode(value) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    if ("type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number") {
+        return { ...value, type: value.type, start: value.start };
+    }
+    return undefined;
+}
+function field(node, key) {
+    return Reflect.get(node, key);
+}
+function nodeAt(node, key) {
+    return asNode(field(node, key));
+}
+function nodesAt(node, key) {
+    const value = field(node, key);
+    if (Array.isArray(value) === false)
+        return [];
+    return value.flatMap((item) => {
+        const n = asNode(item);
+        return n === undefined ? [] : [n];
+    });
+}
+function stringAt(node, key) {
+    const value = field(node, key);
+    return typeof value === "string" ? value : undefined;
+}
+function isComputed(node) {
+    return field(node, "computed") === true;
+}
+const SKIP_KEYS = new Set(["type", "start", "end", "loc", "range", "raw"]);
+function childNodes(node) {
+    return Object.keys(node)
+        .filter((key) => SKIP_KEYS.has(key) === false)
+        .flatMap((key) => {
+        const value = field(node, key);
+        const items = Array.isArray(value) ? value : [value];
+        return items.flatMap((item) => {
+            const child = asNode(item);
+            return child === undefined ? [] : [{ key, child }];
+        });
+    });
+}
+const HOOK_NAME = /^use[A-Z0-9]/;
+function declarePattern(pattern, visit, scan) {
+    switch (pattern.type) {
+        case "Identifier": {
+            const name = stringAt(pattern, "name");
+            if (name !== undefined)
+                scan.declared.add(name);
+            return;
+        }
+        case "ObjectPattern":
+            for (const prop of nodesAt(pattern, "properties")) {
+                if (prop.type === "RestElement") {
+                    const arg = nodeAt(prop, "argument");
+                    if (arg !== undefined)
+                        declarePattern(arg, visit, scan);
+                    continue;
+                }
+                const key = nodeAt(prop, "key");
+                if (key !== undefined && isComputed(prop))
+                    walk({ node: key, parent: prop, key: "key", depth: visit.depth }, scan);
+                const value = nodeAt(prop, "value");
+                if (value !== undefined)
+                    declarePattern(value, visit, scan);
+            }
+            return;
+        case "ArrayPattern":
+            for (const element of nodesAt(pattern, "elements"))
+                declarePattern(element, visit, scan);
+            return;
+        case "RestElement": {
+            const arg = nodeAt(pattern, "argument");
+            if (arg !== undefined)
+                declarePattern(arg, visit, scan);
+            return;
+        }
+        case "AssignmentPattern": {
+            const left = nodeAt(pattern, "left");
+            const right = nodeAt(pattern, "right");
+            if (left !== undefined)
+                declarePattern(left, visit, scan);
+            if (right !== undefined)
+                walk({ node: right, parent: pattern, key: "right", depth: visit.depth }, scan);
+            return;
+        }
+        default:
+            walk({ node: pattern, parent: undefined, key: "", depth: visit.depth }, scan);
+    }
+}
+function declareId(node, scan) {
+    const id = nodeAt(node, "id");
+    const name = id === undefined ? undefined : stringAt(id, "name");
+    if (name !== undefined)
+        scan.declared.add(name);
+}
+function walkFunction(v, scan) {
+    declareId(v.node, scan);
+    const inner = { depth: v.depth + 1 };
+    for (const param of nodesAt(v.node, "params"))
+        declarePattern(param, inner, scan);
+    const body = nodeAt(v.node, "body");
+    if (body !== undefined)
+        walk({ node: body, parent: v.node, key: "body", depth: inner.depth }, scan);
+}
+function jsxReference(name) {
+    switch (name.type) {
+        case "JSXIdentifier": {
+            const id = stringAt(name, "name");
+            if (id === undefined || /^[a-z]/.test(id) || id.includes("-"))
+                return undefined;
+            return { name: id, start: name.start };
+        }
+        case "JSXMemberExpression": {
+            let object = nodeAt(name, "object");
+            while (object !== undefined && object.type === "JSXMemberExpression")
+                object = nodeAt(object, "object");
+            const root = object === undefined ? undefined : stringAt(object, "name");
+            return object === undefined || root === undefined || root === "this" ? undefined : { name: root, start: object.start };
+        }
+        default:
+            return undefined;
+    }
+}
+function isNonReferenceIdentifier(v) {
+    const parent = v.parent;
+    if (parent === undefined)
+        return false;
+    switch (true) {
+        case parent.type === "MemberExpression" && v.key === "property" && isComputed(parent) === false:
+        case (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") &&
+            v.key === "key" &&
+            isComputed(parent) === false:
+        case parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement":
+        case parent.type === "ExportSpecifier" && v.key === "exported":
+        case parent.type === "MetaProperty":
+            return true;
+        default:
+            return false;
+    }
+}
+function walk(v, scan) {
+    const node = v.node;
+    switch (node.type) {
+        case "Identifier": {
+            const name = stringAt(node, "name");
+            if (name !== undefined && isNonReferenceIdentifier(v) === false)
+                scan.refs.push({ name, start: node.start });
+            return;
+        }
+        case "ImportDeclaration":
+        case "ImportExpression":
+        case "ExportAllDeclaration":
+            return;
+        case "ExportNamedDeclaration":
+            if (nodeAt(node, "source") !== undefined)
+                return;
+            break;
+        case "VariableDeclarator": {
+            const id = nodeAt(node, "id");
+            if (id !== undefined)
+                declarePattern(id, v, scan);
+            const init = nodeAt(node, "init");
+            if (init !== undefined)
+                walk({ node: init, parent: node, key: "init", depth: v.depth }, scan);
+            return;
+        }
+        case "FunctionDeclaration":
+        case "FunctionExpression":
+        case "ArrowFunctionExpression":
+            walkFunction(v, scan);
+            return;
+        case "ClassDeclaration":
+        case "ClassExpression": {
+            declareId(node, scan);
+            const superClass = nodeAt(node, "superClass");
+            if (superClass !== undefined)
+                walk({ node: superClass, parent: node, key: "superClass", depth: v.depth }, scan);
+            const body = nodeAt(node, "body");
+            if (body !== undefined)
+                walk({ node: body, parent: node, key: "body", depth: v.depth + 1 }, scan);
+            return;
+        }
+        case "CatchClause": {
+            const param = nodeAt(node, "param");
+            if (param !== undefined)
+                declarePattern(param, v, scan);
+            const body = nodeAt(node, "body");
+            if (body !== undefined)
+                walk({ node: body, parent: node, key: "body", depth: v.depth }, scan);
+            return;
+        }
+        case "UnaryExpression": {
+            const arg = nodeAt(node, "argument");
+            if (stringAt(node, "operator") === "typeof" && arg !== undefined && arg.type === "Identifier")
+                return;
+            break;
+        }
+        case "CallExpression": {
+            const callee = nodeAt(node, "callee");
+            const hook = callee === undefined ? undefined : hookName(callee);
+            if (hook !== undefined && v.depth === 0)
+                scan.hookCalls.push({ name: hook, start: node.start });
+            break;
+        }
+        case "JSXElement": {
+            const opening = nodeAt(node, "openingElement");
+            if (opening !== undefined)
+                walk({ node: opening, parent: node, key: "openingElement", depth: v.depth }, scan);
+            for (const child of nodesAt(node, "children"))
+                walk({ node: child, parent: node, key: "children", depth: v.depth }, scan);
+            return;
+        }
+        case "JSXOpeningElement": {
+            const name = nodeAt(node, "name");
+            const ref = name === undefined ? undefined : jsxReference(name);
+            if (ref !== undefined)
+                scan.refs.push(ref);
+            for (const attr of nodesAt(node, "attributes"))
+                walk({ node: attr, parent: node, key: "attributes", depth: v.depth }, scan);
+            return;
+        }
+        case "JSXAttribute": {
+            const value = nodeAt(node, "value");
+            if (value !== undefined)
+                walk({ node: value, parent: node, key: "value", depth: v.depth }, scan);
+            return;
+        }
+        case "JSXText":
+        case "JSXIdentifier":
+        case "JSXNamespacedName":
+        case "JSXMemberExpression":
+        case "JSXClosingElement":
+        case "JSXClosingFragment":
+        case "JSXOpeningFragment":
+        case "Literal":
+        case "TemplateElement":
+            return;
+        default:
+            break;
+    }
+    for (const { key, child } of childNodes(node))
+        walk({ node: child, parent: node, key, depth: v.depth }, scan);
+}
+function hookName(callee) {
+    switch (callee.type) {
+        case "Identifier": {
+            const name = stringAt(callee, "name");
+            return name !== undefined && HOOK_NAME.test(name) ? name : undefined;
+        }
+        case "MemberExpression": {
+            const property = nodeAt(callee, "property");
+            const name = property === undefined || isComputed(callee) ? undefined : stringAt(property, "name");
+            return name !== undefined && HOOK_NAME.test(name) ? name : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function collectImports(program, scan) {
+    for (const statement of nodesAt(program, "body")) {
+        const source = nodeAt(statement, "source");
+        const spec = source === undefined ? undefined : field(source, "value");
+        if (typeof spec !== "string")
+            continue;
+        switch (statement.type) {
+            case "ImportDeclaration": {
+                const names = [];
+                for (const specifier of nodesAt(statement, "specifiers")) {
+                    const local = nodeAt(specifier, "local");
+                    const localName = local === undefined ? undefined : stringAt(local, "name");
+                    if (localName !== undefined)
+                        scan.declared.add(localName);
+                    const imported = nodeAt(specifier, "imported");
+                    const importedName = imported === undefined ? undefined : (stringAt(imported, "name") ?? stringAt(imported, "value"));
+                    if (specifier.type === "ImportSpecifier" && importedName !== undefined)
+                        names.push(importedName);
+                    if (specifier.type === "ImportDefaultSpecifier")
+                        names.push("default");
+                }
+                scan.imports.push({ spec, start: statement.start, names });
+                break;
+            }
+            case "ExportNamedDeclaration": {
+                const names = nodesAt(statement, "specifiers").flatMap((specifier) => {
+                    const local = nodeAt(specifier, "local");
+                    const name = local === undefined ? undefined : (stringAt(local, "name") ?? stringAt(local, "value"));
+                    return name === undefined ? [] : [name];
+                });
+                scan.imports.push({ spec, start: statement.start, names });
+                break;
+            }
+            case "ExportAllDeclaration":
+                scan.imports.push({ spec, start: statement.start, names: [] });
+                break;
+            default:
+                break;
+        }
+    }
+}
+function collectDynamicImports(node, scan) {
+    if (node.type === "ImportExpression") {
+        const source = nodeAt(node, "source");
+        const spec = source === undefined ? undefined : field(source, "value");
+        if (typeof spec === "string")
+            scan.imports.push({ spec, start: node.start, names: [] });
+    }
+    for (const { child } of childNodes(node))
+        collectDynamicImports(child, scan);
+}
+function lineAt(source, offset) {
+    return source.slice(0, offset).split("\n").length;
+}
+function resolveRelative(from, spec) {
+    const base = spec.startsWith("/") ? [] : from.split("/").slice(1, -1);
+    const parts = [...base];
+    for (const part of spec.split("/")) {
+        switch (part) {
+            case "":
+            case ".":
+                break;
+            case "..":
+                if (parts.length === 0)
+                    return undefined;
+                parts.pop();
+                break;
+            default:
+                parts.push(part);
+        }
+    }
+    return `/${parts.join("/")}`;
+}
+function isRelativeSpecifier(spec) {
+    return spec.startsWith("./") || spec.startsWith("../") || (spec.startsWith("/") && spec.startsWith("//") === false);
+}
+function isBareSpecifier(spec) {
+    return isRelativeSpecifier(spec) === false && /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(spec) === false;
+}
+function parseableSource(path, contents) {
+    if (/\.tsx?$/.test(path) === false)
+        return contents;
+    const stripped = exception2Result(() => transform(contents, { transforms: path.endsWith(".tsx") ? ["typescript", "jsx"] : ["typescript"], jsxRuntime: "preserve" })
+        .code);
+    return stripped.isErr() ? undefined : stripped.Ok();
+}
+const JsxParser = Parser.extend(acornJsx());
+const NOTHING = { findings: [], deps: [] };
+function checkFile(args) {
+    const { path } = args;
+    const source = parseableSource(path, args.contents);
+    if (source === undefined)
+        return NOTHING;
+    const parsed = exception2Result(() => JsxParser.parse(source, { ecmaVersion: "latest", sourceType: "module", allowHashBang: true, allowAwaitOutsideFunction: true }));
+    if (parsed.isErr()) {
+        const message = parsed.Err().message;
+        const at = /\((\d+):\d+\)\s*$/.exec(message);
+        if (message.includes("Expected corresponding JSX closing tag")) {
+            return {
+                findings: [
+                    {
+                        class: "jsx-tag-mismatch",
+                        message: message.replace(/\s*\(\d+:\d+\)\s*$/, ""),
+                        file: path,
+                        line: at === null ? 1 : Number(at[1]),
+                    },
+                ],
+                deps: [],
+            };
+        }
+        return NOTHING;
+    }
+    const program = asNode(parsed.Ok());
+    if (program === undefined)
+        return NOTHING;
+    const scan = { declared: new Set(), refs: [], hookCalls: [], imports: [] };
+    collectImports(program, scan);
+    collectDynamicImports(program, scan);
+    walk({ node: program, parent: undefined, key: "", depth: 0 }, scan);
+    const findings = [];
+    const deps = [];
+    for (const imp of scan.imports) {
+        const line = lineAt(source, imp.start);
+        if (isRelativeSpecifier(imp.spec)) {
+            const target = resolveRelative(path, imp.spec);
+            if (target === undefined || args.vfs.has(target) === false) {
+                findings.push({
+                    class: "import-404",
+                    message: `"${imp.spec}" has no file at ${target ?? "that path"}; the runtime serves exact paths, so write the extension (#6450)`,
+                    file: path,
+                    line,
+                });
+            }
+            else {
+                deps.push(target);
+            }
+            continue;
+        }
+        if (isBareSpecifier(imp.spec) === false)
+            continue;
+        const known = OPENS_MODULE_EXPORTS[imp.spec];
+        if (known !== undefined) {
+            for (const name of imp.names) {
+                if (known.includes(name))
+                    continue;
+                findings.push({
+                    class: "missing-export",
+                    message: name === "default" ? `"${imp.spec}" has no default export` : `"${imp.spec}" has no export named ${name}`,
+                    file: path,
+                    line,
+                });
+            }
+            continue;
+        }
+        if (isMappedSpecifier(imp.spec) === false) {
+            findings.push({
+                class: "unknown-package",
+                message: `"${imp.spec}" is not in the sandbox import map (it would load from esm.sh, if at all)`,
+                file: path,
+                line,
+            });
+        }
+    }
+    const reported = new Set();
+    for (const ref of scan.refs) {
+        if (scan.declared.has(ref.name) || isGlobalName(ref.name) || reported.has(ref.name))
+            continue;
+        reported.add(ref.name);
+        findings.push({
+            class: "undefined-identifier",
+            message: `${ref.name} is used but never imported or declared`,
+            file: path,
+            line: lineAt(source, ref.start),
+        });
+    }
+    for (const hook of scan.hookCalls) {
+        findings.push({
+            class: "hook-at-module-scope",
+            message: `${hook.name}(…) is called at module scope; hooks run inside a component or another hook`,
+            file: path,
+            line: lineAt(source, hook.start),
+        });
+    }
+    return { findings: findings.sort((a, b) => a.line - b.line), deps };
+}
+function isBrowserModule(path) {
+    return /\.(jsx?|tsx?)$/.test(path) && path.startsWith("/~~") === false && path !== "/access.js" && path !== "/backend.js";
+}
+export function checkOpens(vfs) {
+    const entries = [...vfs.keys()].filter((path) => /^\/App\.(jsx|tsx|js|ts)$/.test(path));
+    const queue = entries.length > 0 ? entries : [...vfs.keys()].filter(isBrowserModule);
+    const seen = new Set();
+    const findings = [];
+    for (let next = queue.shift(); next !== undefined; next = queue.shift()) {
+        const contents = vfs.get(next);
+        if (seen.has(next) || contents === undefined || isBrowserModule(next) === false)
+            continue;
+        seen.add(next);
+        const checked = checkFile({ path: next, contents, vfs });
+        findings.push(...checked.findings);
+        queue.push(...checked.deps);
+    }
+    return { opens: findings.every((finding) => OPENS_ADVISORY_CLASSES.has(finding.class)), findings };
+}
+//# sourceMappingURL=opens-check.js.map