ziex 0.1.0-dev.852 → 0.1.0-dev.865

package/bin/ziex

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// Stub that delegates to the native zx binary.
+// The postinstall script copies it to bin/zx, but if that hasn't run
+// (e.g. bunx), we resolve the platform package's binary directly.
+
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const isWindows = process.platform === "win32";
+const ext = isWindows ? ".exe" : "";
+
+function findBinary() {
+  // 1. Check if postinstall already placed the binary
+  const localBin = join(__dirname, `zx${ext}`);
+  if (existsSync(localBin)) return localBin;
+
+  // 2. Resolve from the platform-specific optional dependency
+  const platformPkgs = {
+    "darwin-arm64": "@ziex/cli-darwin-arm64",
+    "darwin-x64": "@ziex/cli-darwin-x64",
+    "linux-x64": "@ziex/cli-linux-x64",
+    "linux-arm64": "@ziex/cli-linux-arm64",
+    "win32-x64": "@ziex/cli-win32-x64",
+    "win32-arm64": "@ziex/cli-win32-arm64",
+  };
+
+  const pkg = platformPkgs[`${process.platform}-${process.arch}`];
+  if (pkg) {
+    try {
+      const pkgDir = dirname(require.resolve(`${pkg}/package.json`));
+      const bin = join(pkgDir, "bin", `zx${ext}`);
+      if (existsSync(bin)) return bin;
+    } catch {}
+  }
+
+  return null;
+}
+
+const bin = findBinary();
+if (!bin) {
+  console.error(
+    "Error: ziex native binary not found. The postinstall script may not have run.",
+  );
+  console.error("Try reinstalling: npm install -g ziex");
+  process.exit(1);
+}
+
+try {
+  execFileSync(bin, process.argv.slice(2), { stdio: "inherit" });
+} catch (e) {
+  if (e.status !== undefined) {
+    process.exit(e.status);
+  }
+  throw e;
+}

package/install.cjs

@@ -0,0 +1,218 @@
+// Postinstall script for ziex npm package
+// Resolves the native binary from platform-specific optionalDependencies
+// or falls back to downloading from GitHub releases.
+
+const { existsSync, mkdirSync, copyFileSync, chmodSync, createWriteStream, unlinkSync } = require("fs");
+const { execSync } = require("child_process");
+const path = require("path");
+const https = require("https");
+const { createGunzip } = require("zlib");
+
+const PLATFORM_MAP = {
+  darwin: {
+    arm64: { pkg: "@ziex/cli-darwin-arm64", target: "macos-aarch64" },
+    x64: { pkg: "@ziex/cli-darwin-x64", target: "macos-x64" },
+  },
+  linux: {
+    x64: { pkg: "@ziex/cli-linux-x64", target: "linux-x64" },
+    arm64: { pkg: "@ziex/cli-linux-arm64", target: "linux-aarch64" },
+  },
+  win32: {
+    x64: { pkg: "@ziex/cli-win32-x64", target: "windows-x64" },
+    arm64: { pkg: "@ziex/cli-win32-arm64", target: "windows-aarch64" },
+  },
+};
+
+const GITHUB_REPO = "ziex-dev/ziex";
+
+function getPlatformInfo() {
+  const os = process.platform;
+  const arch = process.arch;
+  const info = PLATFORM_MAP[os]?.[arch];
+  if (!info) {
+    throw new Error(`Unsupported platform: ${os}-${arch}`);
+  }
+  return info;
+}
+
+function getVersion() {
+  const pkg = require("./package.json");
+  return pkg.version;
+}
+
+function getBinaryName(target) {
+  const isWindows = process.platform === "win32";
+  return `zx-${target}${isWindows ? ".exe" : ""}`;
+}
+
+function getOutputPath() {
+  const binDir = path.join(__dirname, "bin");
+  const isWindows = process.platform === "win32";
+  return path.join(binDir, isWindows ? "zx.exe" : "zx");
+}
+
+// Try to resolve binary from optionalDependencies
+function tryResolveFromOptionalDep(pkgName) {
+  try {
+    const pkgPath = require.resolve(`${pkgName}/package.json`);
+    const pkgDir = path.dirname(pkgPath);
+    const pkgJson = require(pkgPath);
+    const binName = pkgJson.bin?.zx || pkgJson.bin?.ziex;
+    if (binName) {
+      const binPath = path.join(pkgDir, binName);
+      if (existsSync(binPath)) {
+        return binPath;
+      }
+    }
+    // Fallback: look for the binary directly
+    const isWindows = process.platform === "win32";
+    const possibleNames = isWindows ? ["zx.exe"] : ["zx"];
+    for (const name of possibleNames) {
+      const candidate = path.join(pkgDir, "bin", name);
+      if (existsSync(candidate)) return candidate;
+    }
+  } catch {
+    // Package not installed
+  }
+  return null;
+}
+
+// Download from GitHub releases
+function downloadFromGitHub(target, version) {
+  return new Promise((resolve, reject) => {
+    const isWindows = process.platform === "win32";
+    const ext = isWindows ? "zip" : "tar.gz";
+    const tag = version.startsWith("0.") ? `zx-v${version}` : `zx-v${version}`;
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/${tag}/zx-${target}.${ext}`;
+    const latestUrl = `https://github.com/${GITHUB_REPO}/releases/latest/download/zx-${target}.${ext}`;
+
+    const binDir = path.join(__dirname, "bin");
+    mkdirSync(binDir, { recursive: true });
+    const archivePath = path.join(binDir, `zx-${target}.${ext}`);
+
+    console.log(`Downloading ziex binary for ${target}...`);
+
+    function download(downloadUrl, isRetry) {
+      const followRedirect = (url) => {
+        const proto = url.startsWith("https") ? https : require("http");
+        proto
+          .get(url, { headers: { "User-Agent": "ziex-npm" } }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+              followRedirect(res.headers.location);
+              return;
+            }
+            if (res.statusCode !== 200) {
+              if (!isRetry) {
+                // Retry with latest
+                download(latestUrl, true);
+                return;
+              }
+              reject(new Error(`Download failed with status ${res.statusCode}: ${downloadUrl}`));
+              return;
+            }
+
+            const file = createWriteStream(archivePath);
+            res.pipe(file);
+            file.on("finish", () => {
+              file.close(() => resolve(archivePath));
+            });
+          })
+          .on("error", reject);
+      };
+      followRedirect(downloadUrl);
+    }
+
+    download(url, false);
+  });
+}
+
+function extractTarGz(archivePath, targetBinaryName, outputPath) {
+  const binDir = path.dirname(outputPath);
+  // Use tar command (available on macOS and Linux)
+  execSync(`tar -xzf "${archivePath}" -C "${binDir}"`, { stdio: "pipe" });
+  const extractedPath = path.join(binDir, targetBinaryName);
+  if (existsSync(extractedPath)) {
+    copyFileSync(extractedPath, outputPath);
+    unlinkSync(extractedPath);
+  }
+  unlinkSync(archivePath);
+}
+
+function extractZip(archivePath, targetBinaryName, outputPath) {
+  const binDir = path.dirname(outputPath);
+  execSync(`unzip -o "${archivePath}" -d "${binDir}"`, { stdio: "pipe" });
+  const extractedPath = path.join(binDir, targetBinaryName);
+  if (existsSync(extractedPath)) {
+    copyFileSync(extractedPath, outputPath);
+    unlinkSync(extractedPath);
+  }
+  unlinkSync(archivePath);
+}
+
+async function main() {
+  const { pkg: pkgName, target } = getPlatformInfo();
+  const outputPath = getOutputPath();
+  const binDir = path.dirname(outputPath);
+  mkdirSync(binDir, { recursive: true });
+
+  // Step 1: Try to resolve from optional dependency
+  const resolvedPath = tryResolveFromOptionalDep(pkgName);
+  if (resolvedPath) {
+    console.log(`Found ziex binary from ${pkgName}`);
+    copyFileSync(resolvedPath, outputPath);
+    chmodSync(outputPath, 0o755);
+
+    // Create ziex alias (symlink or copy)
+    createAliases(outputPath);
+    return;
+  }
+
+  // Step 2: Download from GitHub releases
+  console.log(`Platform package ${pkgName} not found, downloading from GitHub...`);
+  try {
+    const version = getVersion();
+    const archivePath = await downloadFromGitHub(target, version);
+    const binaryName = getBinaryName(target);
+    const isWindows = process.platform === "win32";
+
+    if (isWindows) {
+      extractZip(archivePath, binaryName, outputPath);
+    } else {
+      extractTarGz(archivePath, binaryName, outputPath);
+    }
+
+    chmodSync(outputPath, 0o755);
+    createAliases(outputPath);
+    console.log("ziex binary installed successfully!");
+  } catch (err) {
+    console.error(`Failed to install ziex binary: ${err.message}`);
+    console.error("You can install it manually from: https://ziex.dev/install");
+    process.exit(1);
+  }
+}
+
+function createAliases(zxPath) {
+  const binDir = path.dirname(zxPath);
+  const isWindows = process.platform === "win32";
+  const ziexPath = path.join(binDir, isWindows ? "ziex.exe" : "ziex");
+
+  // The main binary is `zx`, create `ziex` as a copy/symlink
+  try {
+    if (existsSync(ziexPath) && ziexPath !== zxPath) unlinkSync(ziexPath);
+    if (ziexPath !== zxPath) {
+      try {
+        const fs = require("fs");
+        fs.symlinkSync(path.basename(zxPath), ziexPath);
+      } catch {
+        copyFileSync(zxPath, ziexPath);
+      }
+    }
+  } catch {
+    // Non-critical
+  }
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "ziex",
-  "version": "0.1.0-dev.852",
+  "version": "0.1.0-dev.865",
   "description": "ZX is a framework for building web applications with Zig.",
-  "main": "index.js",
+  "main": "src/index.ts",
   "type": "module",
+  "bin": {
+    "ziex": "bin/ziex",
+    "zx": "bin/ziex"
+  },
   "exports": {
     ".": "./index.js",
     "./react": "./react/index.js",
@@ -32,14 +36,15 @@
   ],
   "author": "Nurul Huda (Apon) <me@nurulhudaapon.com>",
   "license": "MIT",
-  "peerDependenciesMeta": {
-    "react": {
-      "optional": true
-    },
-    "react-dom": {
-      "optional": true
-    }
+  "scripts": {
+    "postinstall": "node install.cjs"
   },
-  "module": "index.js",
-  "types": "index.d.ts"
+  "optionalDependencies": {
+    "@ziex/cli-darwin-arm64": "0.1.0-dev.865",
+    "@ziex/cli-darwin-x64": "0.1.0-dev.865",
+    "@ziex/cli-linux-x64": "0.1.0-dev.865",
+    "@ziex/cli-linux-arm64": "0.1.0-dev.865",
+    "@ziex/cli-win32-x64": "0.1.0-dev.865",
+    "@ziex/cli-win32-arm64": "0.1.0-dev.865"
+  }
 }

package/README.md

@@ -1,195 +0,0 @@
-<p align="center">
-    <img src="https://raw.githubusercontent.com/ziex-dev/branding/main/banner.svg" alt="Ziex banner" width="100%" />
-</p>
-
-A full-stack web framework for Zig. Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
-
-Ziex combines the power and performance of Zig with the expressiveness of JSX, enabling you to build fast, type-safe web applications.
-
-**[Documentation →](https://ziex.dev/learn)**
-
-
-
-> **Note:** Most of the API and syntax are finalized and stable, and server-side rendering (SSR) features are production-ready, Ziex continues to evolve with ongoing improvements to client-side rendering and state management. You can start using the documented features today, as they are stable and unlikely to change. Areas still under development are not yet documented and will be added as they mature.
-
-
-## Installation
-
-##### Linux/macOS
-```bash
-curl -fsSL https://ziex.dev/install | bash
-```
-
-##### Windows
-```powershell
-powershell -c "irm ziex.dev/install.ps1 | iex"
-
-```
-##### Installing Zig
-```bash
-brew install zig # macOS
-winget install -e --id zig.zig # Windows
-```
-[_See for other platforms →_](https://ziglang.org/learn/getting-started/)
-
-
-## At a Glance
-
-```tsx site/pages/examples/playground.zx
-pub fn Playground(allocator: zx.Allocator) zx.Component {
-    const is_loading = true;
-    var i: usize = 0;
-
-    return (
-        <main @allocator={allocator}>
-            <h1>Hello, Ziex!</h1>
-
-            {for (users) |user| (
-                <Profile name={user.name} age={user.age} role={user.role} />
-            )}
-
-            {if (is_loading) (<p>Loading...</p>) else (<p>Loaded</p>)}
-
-            {while (i < 5) : (i += 1) (<i>{i}</i>)}
-        </main>
-    );
-}
-
-fn Profile(ctx: *zx.ComponentCtx(User)) zx.Component {
-    return (
-        <div @allocator={ctx.allocator}>
-            <h3>{ctx.props.name}</h3>
-            <div>{ctx.props.age}</div>
-            <strong>
-                {switch (ctx.props.role) {
-                    .admin => "Admin",
-                    .member => "Member",
-                }}
-            </strong>
-        </div>
-    );
-}
-
-const User = struct { name: []const u8, age: u32, role: enum { admin, member } };
-
-const users = [_]User{
-    .{ .name = "John", .age = 20, .role = .admin },
-    .{ .name = "Jane", .age = 21, .role = .member },
-};
-
-const zx = @import("zx");
-```
-
-Try this in [Playground →](https://ziex.dev/playground#data=eF59U01vnDAQ_StTTtAiyGZVqSKAEuVSVa2USy8NUUTAu2sJbGQgoUv83ztjlo-y2_rCfLx5zMyze-uhSH_vlWxF7h07K7Cq9gV2AuawnRaFzNJGqgCOnXc3eg5597KspGCigT4RgCeTom6A18-FTHMu9hBBo1p2M2RfUwU8gLbmR4aZKwwPCcWaVgmwB49OWKZcwO3086ifTB3PMAM9bOKvDLMu_OKs-xD6GBiZx9PvpAK7rZmqHXin7_vydxPXg5I7XjAQacminnAemRrS_eijpUHJYvTJ1OCvunL0WQt8B_a8GgfssIq_D47neaFfxQ6womZTguUmeM70dqAebQ4hfHYgIOtTBBui5HHPdehzUzYWhD6t89Shg2s3lKTzMK6dNV0AH5eK3jed_RPHcy4LfUGxnL_-JRhyev8RbRsbRKVkVQ87RuG2axiSLnG0-9Cn4ApXN0qK_SpKp6_feJMdwJ5JSDBnHGR9vDQv8eZFMSTWHZmJ5f4DWbLyhakB-sPYF7Far3r1z5pdjjTJM7wl0gDfCpa0GW7fXMwAHp-GbPvFpZuJb2p77ZpLGQATbYlAM4cLpyY16JuZ1LwDZH18fiL-0yq8HowQmEisb_JAowOtHAPXV2gSP9qnFWn3Ulkq2LJssygbW8G6ZTPHDpO3HC-YauzEOnaJRTuw9B927V4U)
-
-<details>
-<summary>Explanation of this</summary>
-
-```tsx site/pages/examples/playground.zx
-// A Zig function that returns a `zx.Component`.
-pub fn Playground(allocator: zx.Allocator) zx.Component {
-    const is_loading = true;
-    var i: usize = 0;
-
-    // HTML Block is always surrounded by parentheses and can contain HTML elements and control flow statements.
-    return (
-        // @allocator or any other attribute starting with `@` is called builtin attribute
-        // `@allocator` is used to specify the allocator for the component and its children for mem allocation.
-        <main @allocator={allocator}>
-            <h1>Hello, Ziex!</h1>
-
-            // `for` loop to iterate over `users` array and render a `Profile` component for each user.
-            // Since this is an expression the HTMLs are inside parenteses not curly braces.
-            {for (users) |user| (
-                // `Profile` component is called with props: name, age, and role.
-                // Optional props can be omitted, and the component will receive default values for them.
-                <Profile name={user.name} age={user.age} role={user.role} />
-            )}
-
-            // `if` statement works just like other control flow statements.
-            {if (is_loading) (<p>Loading...</p>) else (<p>Loaded</p>)}
-
-            // `while` loop with an optional increment statement.
-            {while (i < 5) : (i += 1) (<i>{i}</i>)}
-        </main>
-    );
-}
-
-// A Ziex Component is a Zig function that returns a `zx.Component`.
-// It can have signatures like:
-// - `pub fn ComponentName(allocator: zx.Allocator) zx.Component`
-// - `pub fn ComponentName(ctx: *zx.ComponentCtx<PropsType>) zx.Component`
-// - `pub fn ComponentName(allocator: zx.Allocator, props: PropsType) zx.Component`
-fn Profile(ctx: *zx.ComponentCtx(User)) zx.Component {
-    return (
-        <div @allocator={ctx.allocator}>
-        // Exrepssion starts with `{` and ends with `}`. You can use it to access props, call functions, any valid Zig expression
-            <h3>{ctx.props.name}</h3>
-            <div>{ctx.props.age}</div>
-            <strong>
-                {switch (ctx.props.role) {
-                    .admin => "Admin",
-                    .member => "Member",
-                }}
-            </strong>
-        </div>
-    );
-}
-
-const User = struct { name: []const u8, age: u32, role: enum { admin, member } };
-
-const users = [_]User{
-    .{ .name = "John", .age = 20, .role = .admin },
-    .{ .name = "Jane", .age = 21, .role = .member },
-};
-
-const zx = @import("zx");
-```
-
-</details>
-
-## Features
-- **JSX-like Syntax**: Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
-- **Full-Stack Capabilities**: Build both frontend and backend of your web application using
-- **It's Fast**: Significantly faster at SSR than many other frameworks.
-- **Compile-time Safety**: Zig's type system catches bugs at compile time. No runtime surprises, no GC.
-- **Familiar Syntax**: Familiar JSX-like syntax, or plain HTML-style markup, with full access to Zig's control flow.
-- **Server-side Rendering**: Render per request on the server for dynamic data, auth, and personalized pages for best performance and SEO.
-- **Static Site Generation**: Pre-render pages at build/export time into static HTML for fast CDN delivery.
-- **File System Routing**: Folder structure defines routes. No configs, no magic strings, just files in folders.
-- **Client-side Rendering**: Optional client-side rendering for interactive experiences when you need it.
-- **Control Flow in Zig's Syntax**: if/else, for/while, and switch all work as expected. It's just Zig.
-- **Developer Tooling**: CLI, hot reload, and editor extensions for the best DX.
-
-## Roadmap
-
-We track our feature roadmap and bugs using GitHub Issues. 
-You can view our current progress and planned features here:
-
-**[Check out the Ziex Issue Tracker →](https://github.com/ziex-dev/ziex/issues)**
-
-## Editor Support
-
-* [VSCode](https://marketplace.visualstudio.com/items?itemName=ziex.ziex)/[VSCode Forks](https://open-vsx.org/extension/ziex/ziex) Extension
-* [Neovim](/ide/neovim/)
-* [Helix](/ide/helix/)
-* [Zed](/ide/zed/)
-
-## Community
-
-- [Discord](https://ziex.dev/r/discord)
-- [Topic on Ziggit](https://ziex.dev/r/ziggit)
-- [Project on Zig Discord Community](https://ziex.dev/r/zig-discord) (Join Zig Discord first: https://discord.gg/zig)
-
-
-## Links
-
-* [Codeberg Mirror](https://codeberg.org/ziex-dev/ziex) - ZX repository mirror on Codeberg
-* [ziex.dev](https://github.com/ziex-dev/ziex/tree/main/site) - Official documentation site of ZX made using ZX.
-* [example-blog](https://github.com/ziex-dev/example-blog) - Demo blog web application built with ZX
-* [zx-numbers-game](https://github.com/Andrew-Velox/zx-numbers-game) - ZX numbers game
-* [Comparision with other frameworks](https://ziex.dev/vs)
-
-## Contributing
-
-Contributions are welcome! Currently trying out ZX and reporting issues for edge cases and providing feedback are greatly appreciated.

package/aws-lambda/index.js

@@ -1,126 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/aws-lambda/index.ts
-function isV2(event) {
-  return "requestContext" in event && event.requestContext !== null && "http" in event.requestContext;
-}
-function getMethod(event) {
-  if (isV2(event))
-    return event.requestContext.http.method;
-  return event.httpMethod;
-}
-function getPath(event) {
-  if (isV2(event)) {
-    return event.rawPath + (event.rawQueryString ? `?${event.rawQueryString}` : "");
-  }
-  const e = event;
-  const mvqs = e.multiValueQueryStringParameters;
-  const qs = e.queryStringParameters;
-  let queryString = "";
-  if (mvqs) {
-    queryString = Object.entries(mvqs).flatMap(([k, vs]) => (vs ?? []).map((v) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)).join("&");
-  } else if (qs) {
-    queryString = new URLSearchParams(qs).toString();
-  }
-  return e.path + (queryString ? `?${queryString}` : "");
-}
-function getHeaders(event) {
-  const headers = new Headers;
-  if (event.headers) {
-    for (const [k, v] of Object.entries(event.headers)) {
-      if (v != null)
-        headers.set(k, v);
-    }
-  }
-  if ("multiValueHeaders" in event && event.multiValueHeaders) {
-    for (const [k, vs] of Object.entries(event.multiValueHeaders)) {
-      if (!vs?.length)
-        continue;
-      headers.delete(k);
-      for (const v of vs)
-        headers.append(k, v);
-    }
-  }
-  return headers;
-}
-function getBody(event) {
-  if (!event.body)
-    return null;
-  if (event.isBase64Encoded)
-    return Buffer.from(event.body, "base64");
-  return event.body;
-}
-function toRequest(event, headers) {
-  const method = getMethod(event);
-  const host = headers.get("host") ?? "localhost";
-  const proto = headers.get("x-forwarded-proto") ?? "https";
-  const path = getPath(event);
-  const url = `${proto}://${host}${path}`;
-  const body = ["GET", "HEAD"].includes(method) ? null : getBody(event);
-  return new Request(url, { method, headers, body });
-}
-var TEXT_CONTENT_TYPES = [
-  "text/",
-  "application/json",
-  "application/xml",
-  "application/javascript",
-  "application/xhtml"
-];
-function isBinaryContent(contentType, binaryMediaTypes) {
-  if (binaryMediaTypes.length > 0) {
-    return binaryMediaTypes.some((t) => contentType.includes(t));
-  }
-  return !TEXT_CONTENT_TYPES.some((t) => contentType.startsWith(t));
-}
-async function toLambdaResult(res, binaryMediaTypes) {
-  const responseHeaders = {};
-  const multiValueHeaders = {};
-  res.headers.forEach((value, key) => {
-    if (key in responseHeaders) {
-      multiValueHeaders[key] = [...multiValueHeaders[key] ?? [responseHeaders[key]], value];
-      delete responseHeaders[key];
-    } else if (key in multiValueHeaders) {
-      multiValueHeaders[key].push(value);
-    } else {
-      responseHeaders[key] = value;
-    }
-  });
-  const contentType = res.headers.get("content-type") ?? "";
-  const binary = isBinaryContent(contentType, binaryMediaTypes);
-  let body;
-  let isBase64Encoded = false;
-  if (binary) {
-    body = Buffer.from(await res.arrayBuffer()).toString("base64");
-    isBase64Encoded = true;
-  } else {
-    body = await res.text();
-  }
-  return {
-    statusCode: res.status,
-    headers: responseHeaders,
-    multiValueHeaders,
-    body,
-    isBase64Encoded
-  };
-}
-function handle(app, options = {}) {
-  const binaryMediaTypes = options.binaryMediaTypes ?? [];
-  return async (event, _context) => {
-    const headers = getHeaders(event);
-    const req = toRequest(event, headers);
-    const res = await app.fetch(req);
-    return toLambdaResult(res, binaryMediaTypes);
-  };
-}
-export {
-  handle
-};

package/build.zig

@@ -1,5 +0,0 @@
-const std = @import("std");
-
-pub fn build(b: *std.Build) void {
-    _ = b; // stub
-}

package/build.zig.zon

@@ -1,7 +0,0 @@
-.{
-    .name = .ziex_js,
-    .fingerprint = 0x3428b4e119b455bf,
-    .version = "0.1.0-dev.804",
-    .minimum_zig_version = "0.15.2",
-    .paths = .{""},
-}