@astroscope/airlock 0.1.0 → 0.1.1

package/README.md

@@ -1,5 +1,7 @@
 # @astroscope/airlock
 
+> **Note:** This package is in active development. APIs may change between versions.
+
 Strip excess props from hydrated Astro islands — prevents server data leaking to the client, reduces HTML payload size.
 
 ## Why?
@@ -100,15 +102,15 @@ Currently supports **React / Preact** components (`.tsx`, `.ts`, `.jsx`, `.js`).
 
 The architecture uses a pluggable adapter pattern — Vue and Svelte adapters can be added without changing the core.
 
-## Debug logging
+## Logging
 
-In Astro's verbose mode, airlock logs per-component status:
+Airlock always logs a summary during build:
 
 ```
 [@astroscope/airlock] transformed 3 of 4 hydrated component usage(s)
 ```
 
-Components that aren't transformed (ALLOW_ALL types, no user props) are logged at debug level with the reason.
+Per-component details (ALLOW_ALL types, unresolved imports, etc.) are logged at debug level — visible with `--verbose`.
 
 ## License
 

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/vite-plugin.ts
 import fs from "fs/promises";
+import path3 from "path";
 
 // src/adapters/react.ts
 import path from "path";
@@ -8,34 +9,47 @@ import ts2 from "typescript";
 // src/extractor.ts
 import ts from "typescript";
 function generateZodSchema(checker, propsType) {
-  const ctx = { visiting: /* @__PURE__ */ new Set(), types: /* @__PURE__ */ new Map(), counter: 0 };
+  const ctx = { visiting: /* @__PURE__ */ new Set(), types: /* @__PURE__ */ new Map(), counter: 0, depth: 0 };
   const root = toZod(checker, propsType, ctx);
   if (root === null) return null;
   return {
     root,
-    types: [...ctx.types.values()].map((t) => `const ${t.name}: z.ZodType<any> = z.lazy(() => ${t.code});`)
+    types: [...ctx.types.values()].map((t) => `const ${t.name} = z.lazy(() => ${t.code});`)
   };
 }
 function toZod(checker, type, ctx) {
+  ctx.depth++;
+  if (ctx.depth > 50) {
+    ctx.depth--;
+    return "z.any()";
+  }
   if (ctx.visiting.has(type)) return getOrCreateLazyRef(checker, type, ctx);
   const unwrapped = unwrapOptional(type);
+  if (ctx.visiting.has(unwrapped)) return getOrCreateLazyRef(checker, unwrapped, ctx);
   if (isLeaf(unwrapped)) return null;
   if (unwrapped.isUnion() && unwrapped.types.every((t) => isLeaf(t))) return null;
-  if (checker.isArrayType(type) || checker.isArrayType(unwrapped)) {
-    return arrayToZod(checker, checker.isArrayType(type) ? type : unwrapped, ctx);
-  }
-  if (hasIndexSignature(checker, unwrapped)) return null;
-  if (unwrapped.isUnion()) {
-    const discriminant = findDiscriminant(checker, unwrapped);
-    if (discriminant) return discriminatedUnionToZod(checker, unwrapped, discriminant, ctx);
+  ctx.visiting.add(type);
+  ctx.visiting.add(unwrapped);
+  try {
+    if (checker.isArrayType(type) || checker.isArrayType(unwrapped)) {
+      return arrayToZod(checker, checker.isArrayType(type) ? type : unwrapped, ctx);
+    }
+    if (hasIndexSignature(checker, unwrapped)) return null;
+    if (unwrapped.isUnion()) {
+      const discriminant = findDiscriminant(checker, unwrapped);
+      if (discriminant) return discriminatedUnionToZod(checker, unwrapped, discriminant, ctx);
+    }
+    const properties = collectProperties(checker, unwrapped);
+    if (!properties) return null;
+    return propsToZodObject(checker, properties, ctx);
+  } finally {
+    ctx.visiting.delete(type);
+    ctx.visiting.delete(unwrapped);
+    ctx.depth--;
   }
-  const properties = collectProperties(checker, unwrapped);
-  if (!properties) return null;
-  return propsToZodObject(checker, properties, type, ctx);
 }
-function propsToZodObject(checker, properties, type, ctx) {
+function propsToZodObject(checker, properties, ctx) {
   if (properties.size === 0) return "z.object({})";
-  ctx.visiting.add(type);
   const fields = [];
   for (const [name, prop] of properties) {
     const propType = checker.getTypeOfSymbol(prop);
@@ -45,7 +59,6 @@ function propsToZodObject(checker, properties, type, ctx) {
     }
     fields.push(`${safeKey(name)}: ${toZod(checker, propType, ctx) ?? "z.any()"}`);
   }
-  ctx.visiting.delete(type);
   return `z.object({${fields.join(", ")}})`;
 }
 function collectProperties(checker, type) {
@@ -421,23 +434,24 @@ async function transformCompiledOutput(code, schemas) {
   const babel = await import("@babel/core");
   const schemaMap = /* @__PURE__ */ new Map();
   for (const m of schemas) {
-    schemaMap.set(stripExt(m.componentPath), m.schemaId);
+    schemaMap.set(m.specifier, m.schemaId);
+    schemaMap.set(stripExt(m.resolvedPath), m.schemaId);
   }
   const matched = /* @__PURE__ */ new Set();
   const usedSchemaIds = /* @__PURE__ */ new Set();
   let renderComponentFound = false;
   const plugin = ({ types: t }) => ({
     visitor: {
-      ImportDeclaration(path3) {
-        if (!path3.node.source.value.includes("compiler-runtime")) return;
-        for (const specifier of path3.node.specifiers) {
+      ImportDeclaration(path4) {
+        if (!path4.node.source.value.includes("compiler-runtime")) return;
+        for (const specifier of path4.node.specifiers) {
           if (specifier.type !== "ImportSpecifier") continue;
           const imported = specifier.imported;
           const importedName = "name" in imported ? imported.name : imported.value;
           if (importedName !== "renderComponent") continue;
           renderComponentFound = true;
           const localName = specifier.local.name;
-          const binding = path3.scope.getBinding(localName);
+          const binding = path4.scope.getBinding(localName);
           if (!binding) break;
           for (const refPath of binding.referencePaths) {
             const callPath = refPath.parentPath;
@@ -469,19 +483,19 @@ async function transformCompiledOutput(code, schemas) {
   });
   if (!renderComponentFound) {
     throw new Error(
-      "[@astroscope/airlock] could not find renderComponent import in compiled output. this may indicate a breaking change in Astro's compilation format. airlock refuses to continue to prevent potential data leaks."
+      "could not find renderComponent import in compiled output. this may indicate a breaking change in Astro's compilation format. airlock refuses to continue to prevent potential data leaks."
     );
   }
   for (const m of schemas) {
-    const pathWithoutExt = stripExt(m.componentPath);
-    if (!matched.has(pathWithoutExt)) {
+    if (!matched.has(m.specifier) && !matched.has(stripExt(m.resolvedPath))) {
+      const foundPaths = [...matched].join(", ") || "(none)";
       throw new Error(
-        `[@astroscope/airlock] component "${pathWithoutExt}" was detected in .astro source but not found in compiled output. airlock refuses to continue to prevent potential data leaks.`
+        `component "${m.specifier}" was detected in .astro source but not found in compiled output (matched: ${foundPaths}). airlock refuses to continue to prevent potential data leaks.`
       );
     }
   }
   if (!result?.code) {
-    throw new Error("[@astroscope/airlock] babel transform returned no output.");
+    throw new Error("babel transform returned no output.");
   }
   const imports = [...usedSchemaIds, "__airlock_strip"];
   const importLine = `import { ${imports.join(", ")} } from '${VIRTUAL_MODULE_ID}';`;
@@ -511,16 +525,35 @@ function airlockVitePlugin(options) {
   let totalTransformed = 0;
   let registry;
   let server;
+  let root;
+  let isBuild = false;
   return {
     name: "@astroscope/airlock",
     // note: no applyToEnvironment — handleHotUpdate must fire for all environments
     // the transform hook checks for .astro files, so client env is skipped naturally
     configResolved(config) {
-      registry = new SchemaRegistry([new ReactAdapter(config.root, logger)]);
+      root = config.root;
+      isBuild = config.command === "build";
+      registry = new SchemaRegistry([new ReactAdapter(root, logger)]);
     },
     configureServer(devServer) {
       server = devServer;
     },
+    async buildStart() {
+      if (!isBuild) return;
+      const srcDir = path3.join(root, "src");
+      const entries = await fs.readdir(srcDir, { recursive: true, withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".astro")) continue;
+        const filePath = path3.join(entry.parentPath, entry.name);
+        const raw = await fs.readFile(filePath, "utf-8");
+        const analyzed = await analyzeAstroSource(raw);
+        for (const comp of analyzed.hydratedComponents) {
+          if (!comp.importInfo) continue;
+          registry.resolve(comp.importInfo.specifier, comp.importInfo.exportName, filePath);
+        }
+      }
+    },
     resolveId(id) {
       if (id === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_MODULE_ID;
     },
@@ -555,7 +588,11 @@ function airlockVitePlugin(options) {
           logger.debug(`<${comp.name}> (${comp.importInfo.specifier}) \u2014 ALLOW_ALL`);
           continue;
         }
-        componentsToWrap.push({ componentPath: resolved.resolvedPath, schemaId: resolved.schemaId });
+        componentsToWrap.push({
+          specifier: comp.importInfo.specifier,
+          resolvedPath: resolved.resolvedPath,
+          schemaId: resolved.schemaId
+        });
       }
       if (componentsToWrap.length === 0) return;
       if (server) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astroscope/airlock",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Strip excess props from hydrated Astro islands to prevent server data leakage",
   "type": "module",
   "main": "./dist/index.js",