@absolutejs/geometry 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,88 @@
+# Business Source License 1.1
+
+**Licensor:** Alex Kahn
+
+**Licensed Work:** @absolutejs/geometry (https://github.com/absolutejs/geometry)
+
+**Change Date:** October 26, 2030
+
+**Change License:** Apache License, Version 2.0
+
+---
+
+## Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, permitting limited production use.
+
+### Additional Use Grant
+
+You may use the Licensed Work in production, provided your use does not include
+any of the following:
+
+1. **Offering a Competing Service.** You may not offer the Licensed Work, or
+   any derivative or substantial portion of it, to third parties as a hosted or
+   managed service that competes with a hosted geometry processing or 3D asset analysis service. This includes any
+   product whose primary value to its users is the functionality the Licensed
+   Work provides.
+
+2. **Resale or Redistribution as a Standalone Product.** You may not sell,
+   license, or distribute the Licensed Work, or any derivative or fork of it,
+   as a standalone commercial product.
+
+3. **Removal of Attribution.** Any derivative work, fork, or redistribution of
+   the Licensed Work must prominently credit AbsoluteJS and include a link to
+   the original project repository (https://github.com/absolutejs/geometry).
+
+For clarity, the following uses are expressly permitted:
+
+- Using the Licensed Work to build and operate your own applications, websites,
+  internal tools, or SaaS products (whether commercial or non-commercial), so
+  long as the Licensed Work itself is not the primary product you are selling.
+- Using the Licensed Work as a dependency in commercial software you build and
+  sell, as long as the software is not itself a competing managed service of
+  the kind described in clause 1.
+- Providing consulting, development, or professional services to clients using
+  the Licensed Work.
+- Forking and modifying the Licensed Work for your own internal use, provided
+  attribution is maintained.
+
+### Change Date and Change License
+
+On the Change Date specified above, or on such other date as the Licensor may
+specify by written notice, the Licensed Work will be made available under the
+Change License (Apache License, Version 2.0). Until the Change Date, the terms
+of this Business Source License 1.1 apply.
+
+### Trademark
+
+This license does not grant you any rights to use the "AbsoluteJS" or
+"@absolutejs" name, logo, or any related trademarks. Forks and derivative works
+must not be named or branded in a manner that suggests endorsement by or
+affiliation with AbsoluteJS or the Licensor.
+
+### Notices
+
+You must not remove or obscure any licensing, copyright, or other notices
+included in the Licensed Work.
+
+### No Warranty
+
+THE LICENSED WORK IS PROVIDED "AS IS". THE LICENSOR HEREBY DISCLAIMS ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR
+IN CONNECTION WITH THE LICENSED WORK OR THE USE OR OTHER DEALINGS IN THE
+LICENSED WORK.
+
+---
+
+## Contact
+
+For commercial licensing inquiries or additional permissions, contact:
+
+- **Alex Kahn**
+- alexkahndev@gmail.com
+- alexkahndev.github.io

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# @absolutejs/geometry
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Worker-side measurement of alpha-masked triangle geometry. The first API measures
+orthographic coverage without Three.js, a renderer, or a GPU. This is useful for
+asset inspection, canopy gap measurement, and tools in a 3D website builder.
+
+```ts
+import { projectAlphaCoverage } from '@absolutejs/geometry';
+
+const measurement = projectAlphaCoverage({
+  positions: new Float64Array([0, 0, 0, 1, 0, 0, 0, 0, 1]),
+  uv: new Float32Array([0, 0, 1, 0, 0, 1]),
+  indices: new Uint16Array([0, 1, 2]),
+  alpha: new Uint8Array([255]),
+  textureWidth: 1,
+  textureHeight: 1,
+  cutoff: 0.4,
+  resolution: 256,
+});
+console.log(measurement.footprintArea, measurement.gapFraction);
+```
+
+## Coordinate and texture contract
+
+Positions are xyz in the caller's projection frame, projected onto xz. Supply
+transformed positions for the actual pose, preferably in local double precision.
+An origin already rounded away in Float32 cannot be recovered. Indexed vertices
+define a convex reference hull; its area includes transparent card extents and
+gaps between disconnected leaves. This is a declared reference footprint, not a
+botanical crown boundary. Units are caller-defined; areas use squared units.
+
+UVs must already include any texture transform. Alpha is row-major, one byte per
+texel, with v=0 at the first row: apply any image flip before calling. Bilinear
+sampling uses the base texture level, wrapS/wrapT default to clamp, and alpha at
+or above cutoff is covered. Repeat and mirrored repeat are supported. Faces are
+two-sided; overlapping faces form a union. No color-space conversion applies to
+alpha. Material opacity, vertex alpha, multiple materials and blend materials
+must be resolved by the caller; this API does not silently approximate them.
+
+## Results and accuracy
+
+`cells` is a resolution-squared mask: 0 outside the reference hull, 1 open,
+2 covered. Rows run from minZ to maxZ; columns from minX to maxX. `bounds` is
+[minX, minZ, maxX, maxZ]. `footprintArea` is the analytic hull area;
+`sampledFootprintArea` and `sampledCoveredArea` expose center-sampling error.
+`coveredArea` normalizes the sampled coverage fraction to the analytic hull.
+`gapFraction` is the open fraction of sampled hull cells.
+
+Center sampling can miss thin geometry and small holes. Compare resolutions for
+your asset; convergence is evidence, not a rigorous error bound. The game asset
+audit in docs covers all eight canonical trees plus deformed and fallen examples.
+This does not measure light transmission, rainfall interception, storage capacity,
+wind deformation, mip-filtered screen coverage, or hydrologic history.
+
+## Cost and ownership
+
+Run this synchronous function in a worker or an offline asset pipeline, never a
+render loop. It does not mutate input buffers. Transfer owned copies when worker
+ownership must change; do not detach a renderer's borrowed geometry buffers.
+
+Limits: 300,000 vertices, 200,000 triangles, 4,194,304 texture texels, resolution
+8–1024, finite UV magnitudes at most 1,000,000. Triangle-local bounding rectangles
+are charged against `maxPixelTests` (default 50 million, maximum 100 million)
+before rasterization. The counter is conservative even when union early-outs
+skip already covered cells. Hull construction sorts indexed vertices; scanline
+setup walks convex hull edges. These limits bound work and allocation, not wall
+time. Worker owners should additionally enforce deadlines and cancellation.
+Malformed, unresolved, degenerate and over-budget inputs throw.
+
+## Development
+
+BVM selects Bun `1.4.4+absolute.1` from `.bun-version`.
+Run `bun install --frozen-lockfile` and `bun run check:package`.
+`bun scripts/audit-game-canopies.ts` additionally requires the Hello World checkout
+and its development asset tooling; see docs/canopy-audit/README.md.
+
+Licensed under BSL-1.1; see LICENSE for the additional use grant and change date.
+
+## Worker-side alpha preparation (0.1.1)
+
+`alphaFromRgba(rgba, width, height)` copies one alpha byte per RGBA8 texel into an
+owned Uint8Array. It accepts Uint8Array or Uint8ClampedArray and validates the
+exact byte length and the same 4,194,304-texel budget before allocation.
+
+`alphaFromImageBitmap(bitmap)` reads an already decoded bitmap using a temporary
+OffscreenCanvas 2D context with `willReadFrequently: true`. Call it in a worker;
+it performs synchronous CPU readback wherever it is called. The temporary canvas
+is released afterward. It does not create a WebGL context, close the input bitmap,
+or detach any borrowed renderer resource. The caller owns bitmap cleanup.
+Unsupported runtimes, closed/invalid bitmaps and oversized images fail explicitly.
+There is no hidden main-thread fallback.
+
+ImageBitmap supports structured cloning as well as transfer. The browser-worker
+qualification checks exact alpha values and that closing a cloned worker image
+leaves its source usable. Transfer only owned copies if using a transfer list.
+See the [HTML ImageBitmap ownership contract](https://html.spec.whatwg.org/multipage/imagebitmap-and-animations.html#imagebitmap)
+and [OffscreenCanvas](https://developer.mozilla.org/en-US/docs/Web/API/OffscreenCanvas).
+These helpers prepare raster inputs; they do not assign hydrologic meaning to alpha.

package/dist/alpha.d.ts

@@ -0,0 +1,5 @@
+/** Copy one alpha byte per row-major RGBA8 texel. Does not mutate borrowed pixels. */
+export declare function alphaFromRgba(rgba: Uint8Array | Uint8ClampedArray, width: number, height: number): Uint8Array;
+/** Worker/setup-time CPU readback. The caller owns and closes the bitmap.
+ * This never closes/detaches the caller's image and never creates a WebGL context. */
+export declare function alphaFromImageBitmap(bitmap: ImageBitmap): Uint8Array;

package/dist/alpha.js

@@ -0,0 +1,37 @@
+const MAX_TEXELS = 4_194_304;
+function validateSize(width, height) {
+    if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || width * height > MAX_TEXELS)
+        throw Error('Invalid or oversized alpha source');
+}
+/** Copy one alpha byte per row-major RGBA8 texel. Does not mutate borrowed pixels. */
+export function alphaFromRgba(rgba, width, height) {
+    validateSize(width, height);
+    if (!(rgba instanceof Uint8Array || rgba instanceof Uint8ClampedArray) || rgba.length !== width * height * 4)
+        throw Error('Expected tightly packed RGBA8 alpha source');
+    const alpha = new Uint8Array(width * height);
+    for (let i = 0; i < alpha.length; i++)
+        alpha[i] = rgba[i * 4 + 3];
+    return alpha;
+}
+/** Worker/setup-time CPU readback. The caller owns and closes the bitmap.
+ * This never closes/detaches the caller's image and never creates a WebGL context. */
+export function alphaFromImageBitmap(bitmap) {
+    if (typeof ImageBitmap === 'undefined' || !(bitmap instanceof ImageBitmap))
+        throw Error('Expected an available ImageBitmap');
+    validateSize(bitmap.width, bitmap.height);
+    if (typeof OffscreenCanvas === 'undefined')
+        throw Error('OffscreenCanvas is unavailable for alpha readback');
+    const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
+    try {
+        const context = canvas.getContext('2d', { willReadFrequently: true });
+        if (!context)
+            throw Error('Canvas2D is unavailable for alpha readback');
+        context.drawImage(bitmap, 0, 0);
+        const pixels = context.getImageData(0, 0, bitmap.width, bitmap.height);
+        return alphaFromRgba(pixels.data, pixels.width, pixels.height);
+    }
+    finally {
+        canvas.width = 0;
+        canvas.height = 0;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { projectAlphaCoverage, type AlphaProjectionInput, type AlphaProjection, } from "./projection.js";
+export { alphaFromRgba, alphaFromImageBitmap } from './alpha.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { projectAlphaCoverage, } from "./projection.js";
+export { alphaFromRgba, alphaFromImageBitmap } from './alpha.js';

package/dist/projection.d.ts

@@ -0,0 +1,37 @@
+export type AlphaProjectionInput = {
+    /** xyz coordinates in the requested projection frame; projection is onto xz. */
+    positions: Float32Array | Float64Array;
+    uv: Float32Array | Float64Array;
+    indices: Uint16Array | Uint32Array;
+    alpha: Uint8Array;
+    textureWidth: number;
+    textureHeight: number;
+    cutoff: number;
+    wrapS?: "clamp" | "repeat" | "mirror";
+    wrapT?: "clamp" | "repeat" | "mirror";
+    resolution?: number;
+    maxPixelTests?: number;
+};
+export type AlphaProjection = {
+    revision: "alpha-projection-1";
+    resolution: number;
+    /** 0 outside projected vertex hull, 1 open ray, 2 alpha-covered ray. */
+    cells: Uint8Array;
+    bounds: [number, number, number, number];
+    footprintArea: number;
+    sampledFootprintArea: number;
+    sampledCoveredArea: number;
+    coveredArea: number;
+    gapFraction: number;
+    coveredCells: number;
+    footprintCells: number;
+    pixelTests: number;
+    alphaTests: number;
+    triangles: number;
+    cellArea: number;
+};
+/** Deterministic setup/worker-time orthographic coverage. Triangle-local raster
+ * bounds and union early-outs avoid a ray/triangle cartesian product. The convex
+ * projected vertex hull defines the explicit reference area. Center sampling is
+ * approximate; qualify resolution convergence. No water, transmission or wind. */
+export declare function projectAlphaCoverage(input: AlphaProjectionInput): AlphaProjection;

package/dist/projection.js

@@ -0,0 +1,188 @@
+/** Deterministic setup/worker-time orthographic coverage. Triangle-local raster
+ * bounds and union early-outs avoid a ray/triangle cartesian product. The convex
+ * projected vertex hull defines the explicit reference area. Center sampling is
+ * approximate; qualify resolution convergence. No water, transmission or wind. */
+export function projectAlphaCoverage(input) {
+    const { positions: p, uv, indices, alpha, textureWidth: w, textureHeight: h, cutoff, } = input;
+    const n = input.resolution ?? 256, limit = input.maxPixelTests ?? 50000000;
+    const wrapS = input.wrapS ?? "clamp", wrapT = input.wrapT ?? "clamp";
+    if (!(p instanceof Float32Array || p instanceof Float64Array) ||
+        !(uv instanceof Float32Array || uv instanceof Float64Array) ||
+        !(indices instanceof Uint16Array || indices instanceof Uint32Array) ||
+        !(alpha instanceof Uint8Array) ||
+        p.length % 3 ||
+        p.length < 9 ||
+        p.length > 900000 ||
+        uv.length !== (p.length / 3) * 2 ||
+        indices.length % 3 ||
+        indices.length < 3 ||
+        indices.length > 600000 ||
+        !Number.isInteger(w) ||
+        !Number.isInteger(h) ||
+        w < 1 ||
+        h < 1 ||
+        w * h > 4194304 ||
+        alpha.length !== w * h ||
+        !Number.isFinite(cutoff) ||
+        cutoff <= 0 ||
+        cutoff >= 1 ||
+        !Number.isInteger(n) ||
+        n < 8 ||
+        n > 1024 ||
+        !Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > 100000000 ||
+        !["clamp", "repeat", "mirror"].includes(wrapS) ||
+        !["clamp", "repeat", "mirror"].includes(wrapT))
+        throw Error("Invalid alpha projection input");
+    const count = p.length / 3;
+    let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;
+    const used = new Uint8Array(count);
+    for (const id of indices) {
+        if (id >= count)
+            throw Error("Invalid projection index");
+        used[id] = 1;
+    }
+    for (let i = 0; i < count; i++) {
+        if (![p[i * 3], p[i * 3 + 1], p[i * 3 + 2], uv[i * 2], uv[i * 2 + 1]].every(Number.isFinite) ||
+            Math.abs(uv[i * 2]) > 1e6 ||
+            Math.abs(uv[i * 2 + 1]) > 1e6)
+            throw Error("Nonfinite or unbounded projection vertex");
+        if (!used[i])
+            continue;
+        minX = Math.min(minX, p[i * 3]);
+        maxX = Math.max(maxX, p[i * 3]);
+        minZ = Math.min(minZ, p[i * 3 + 2]);
+        maxZ = Math.max(maxZ, p[i * 3 + 2]);
+    }
+    const spanX = maxX - minX, spanZ = maxZ - minZ;
+    if (!Number.isFinite(spanX * spanZ) || spanX <= 0 || spanZ <= 0)
+        throw Error("Degenerate projection footprint");
+    const coordinates = new Float64Array(count * 2), points = [];
+    for (let i = 0; i < count; i++) {
+        coordinates[i * 2] = p[i * 3] - minX;
+        coordinates[i * 2 + 1] = p[i * 3 + 2] - minZ;
+        if (used[i])
+            points.push(i);
+    }
+    points.sort((a, b) => coordinates[a * 2] - coordinates[b * 2] ||
+        coordinates[a * 2 + 1] - coordinates[b * 2 + 1]);
+    const cross = (a, b, c) => (coordinates[b * 2] - coordinates[a * 2]) *
+        (coordinates[c * 2 + 1] - coordinates[a * 2 + 1]) -
+        (coordinates[b * 2 + 1] - coordinates[a * 2 + 1]) *
+            (coordinates[c * 2] - coordinates[a * 2]);
+    const lower = [], upper = [];
+    for (const id of points) {
+        while (lower.length > 1 && cross(lower.at(-2), lower.at(-1), id) <= 0)
+            lower.pop();
+        lower.push(id);
+    }
+    for (let i = points.length - 1; i >= 0; i--) {
+        const id = points[i];
+        while (upper.length > 1 && cross(upper.at(-2), upper.at(-1), id) <= 0)
+            upper.pop();
+        upper.push(id);
+    }
+    const hull = lower.slice(0, -1).concat(upper.slice(0, -1));
+    let area = 0;
+    for (let i = 0; i < hull.length; i++) {
+        const a = hull[i], b = hull[(i + 1) % hull.length];
+        area +=
+            coordinates[a * 2] * coordinates[b * 2 + 1] -
+                coordinates[b * 2] * coordinates[a * 2 + 1];
+    }
+    area = Math.abs(area) / 2;
+    if (!Number.isFinite(area) || !(area > 0))
+        throw Error("Degenerate projected vertex hull");
+    const dx = spanX / n, dz = spanZ / n, cells = new Uint8Array(n * n);
+    let footprintCells = 0;
+    // Walk hull edges once. A convex hull has at most two crossings per row,
+    // avoiding resolution × hull-vertex work on highly detailed assets.
+    const lefts = new Float64Array(n).fill(Infinity);
+    const rights = new Float64Array(n).fill(-Infinity);
+    for (let i = 0; i < hull.length; i++) {
+        const a = hull[i], b = hull[(i + 1) % hull.length];
+        const az = coordinates[a * 2 + 1], bz = coordinates[b * 2 + 1];
+        if (az === bz)
+            continue;
+        const firstRow = Math.max(0, Math.ceil(Math.min(az, bz) / dz - 0.5));
+        const endRow = Math.min(n, Math.ceil(Math.max(az, bz) / dz - 0.5));
+        for (let row = firstRow; row < endRow; row++) {
+            const z = (row + 0.5) * dz;
+            const x = coordinates[a * 2] +
+                ((z - az) / (bz - az)) * (coordinates[b * 2] - coordinates[a * 2]);
+            lefts[row] = Math.min(lefts[row], x);
+            rights[row] = Math.max(rights[row], x);
+        }
+    }
+    for (let row = 0; row < n; row++) {
+        const left = lefts[row], right = rights[row];
+        const first = Math.max(0, Math.ceil(left / dx - 0.5)), last = Math.min(n - 1, Math.floor(right / dx - 0.5));
+        for (let col = first; col <= last; col++) {
+            cells[row * n + col] = 1;
+            footprintCells++;
+        }
+    }
+    if (!footprintCells)
+        throw Error("Projection footprint is unresolved");
+    const wrap = (index, size, mode) => {
+        if (mode === "clamp")
+            return Math.max(0, Math.min(size - 1, index));
+        const period = mode === "mirror" ? size * 2 : size, t = ((index % period) + period) % period;
+        return t < size ? t : period - 1 - t;
+    };
+    const sample = (u, v) => {
+        const x = u * w - 0.5, y = v * h - 0.5, ix = Math.floor(x), iy = Math.floor(y), fx = x - ix, fy = y - iy;
+        const x0 = wrap(ix, w, wrapS), x1 = wrap(ix + 1, w, wrapS), y0 = wrap(iy, h, wrapT), y1 = wrap(iy + 1, h, wrapT);
+        return ((alpha[y0 * w + x0] * (1 - fx) + alpha[y0 * w + x1] * fx) * (1 - fy) +
+            (alpha[y1 * w + x0] * (1 - fx) + alpha[y1 * w + x1] * fx) * fy);
+    };
+    let pixelTests = 0, alphaTests = 0, coveredCells = 0;
+    for (let t = 0; t < indices.length; t += 3) {
+        const a = indices[t], b = indices[t + 1], c = indices[t + 2];
+        const ax = coordinates[a * 2], az = coordinates[a * 2 + 1], bx = coordinates[b * 2], bz = coordinates[b * 2 + 1], cx = coordinates[c * 2], cz = coordinates[c * 2 + 1];
+        const den = (bx - ax) * (cz - az) - (bz - az) * (cx - ax);
+        if (Math.abs(den) <= Number.EPSILON * (spanX * spanZ))
+            continue;
+        const firstX = Math.max(0, Math.ceil(Math.min(ax, bx, cx) / dx - 0.5)), lastX = Math.min(n - 1, Math.floor(Math.max(ax, bx, cx) / dx - 0.5));
+        const firstZ = Math.max(0, Math.ceil(Math.min(az, bz, cz) / dz - 0.5)), lastZ = Math.min(n - 1, Math.floor(Math.max(az, bz, cz) / dz - 0.5));
+        const work = Math.max(0, lastX - firstX + 1) * Math.max(0, lastZ - firstZ + 1);
+        if (pixelTests + work > limit)
+            throw Error("Alpha projection pixel-test budget exceeded");
+        pixelTests += work;
+        for (let row = firstZ; row <= lastZ; row++)
+            for (let col = firstX; col <= lastX; col++) {
+                const cell = row * n + col;
+                if (cells[cell] !== 1)
+                    continue;
+                const rx = (col + 0.5) * dx - ax, rz = (row + 0.5) * dz - az;
+                const b1 = (rx * (cz - az) - rz * (cx - ax)) / den, b2 = ((bx - ax) * rz - (bz - az) * rx) / den, b0 = 1 - b1 - b2;
+                if (b0 < -1e-10 || b1 < -1e-10 || b2 < -1e-10)
+                    continue;
+                alphaTests++;
+                if (sample(uv[a * 2] * b0 + uv[b * 2] * b1 + uv[c * 2] * b2, uv[a * 2 + 1] * b0 + uv[b * 2 + 1] * b1 + uv[c * 2 + 1] * b2) >=
+                    cutoff * 255) {
+                    cells[cell] = 2;
+                    coveredCells++;
+                }
+            }
+    }
+    const cellArea = dx * dz;
+    return {
+        revision: "alpha-projection-1",
+        resolution: n,
+        cells,
+        bounds: [minX, minZ, maxX, maxZ],
+        footprintArea: area,
+        sampledFootprintArea: footprintCells * cellArea,
+        sampledCoveredArea: coveredCells * cellArea,
+        coveredArea: (area * coveredCells) / footprintCells,
+        gapFraction: 1 - coveredCells / footprintCells,
+        coveredCells,
+        footprintCells,
+        pixelTests,
+        alphaTests,
+        triangles: indices.length / 3,
+        cellArea,
+    };
+}

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@absolutejs/geometry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Bounded alpha-aware geometry projection for worker-side asset measurement and web 3D tooling.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "license": "BSL-1.1",
+  "author": "Alex Kahn",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/absolutejs/geometry.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "bun test ./tests",
+    "check:package": "bun run build && bun test ./tests"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "@types/bun": "1.4.2"
+  }
+}