hara-native 0.1.8

HAL-free native host runtime and package launcher for Hara
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

import { readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import { test, expect } from "@playwright/test";
import { readFoundationResources } from "./conformance-bootstrap.js";

const specsRoot = new URL(
  "../../../../hara-specs-registry/01-lang/001-language/draft/conformance/fixtures/",
  import.meta.url
);

function passingResultCount(value) {
  return value.match(/:pass true/g)?.length ?? 0;
}

test("browser Wasm consumes the specs-owned protocol corpora", async ({ page }) => {
  const [behavioral, surface] = await Promise.all([
    readFile(fileURLToPath(new URL("protocol_behavioral.hal", specsRoot)), "utf8"),
    readFile(fileURLToPath(new URL("protocol_surface.hal", specsRoot)), "utf8")
  ]);

  expect(behavioral).not.toMatch(/std\.protocol\.[^\s/]+\/I[A-Z]/);
  expect(surface).not.toMatch(/std\.protocol\.[^\s/]+\/I[A-Z]/);
  const resources = await readFoundationResources();

  await page.goto("/rust/web/index.html");
  const observed = await page.evaluate(async ({ behavioral, surface, resources }) => {
    const { start } = await import(
      "/rust/web/packages/browser/dist/hara-wasm-full/hara.mjs"
    );
    const hara = await start({ resources });
    for (const namespace of Object.keys(resources)) hara.require(namespace);
    hara.eval("(ns user)");
    if (
      !hara.raw ||
      typeof hara.eval !== "function" ||
      typeof hara.compileBytecode !== "function" ||
      typeof hara.evalBytecode !== "function"
    ) {
      throw new Error("full browser runtime is absent");
    }

    const portable = String(hara.eval(behavioral));
    const capability = String(hara.eval("(capability-protocol-results)"));
    const receivers = String(hara.eval("(protocol-receiver-matrix-results)"));
    const crossCutting = String(hara.eval("(protocol-cross-cutting-results)"));
    const capabilityReceivers = String(
      hara.eval("(protocol-capability-receiver-results)")
    );
    const nativeValues = String(hara.eval("(protocol-native-value-results)"));
    const predicates = String(hara.eval("(protocol-predicate-results)"));
    const compilerProbe =
      "(every? :pass (protocol-receiver-matrix-results))";
    const interpreted = String(hara.eval(compilerProbe));
    const compiled = String(
      hara.evalBytecode(hara.compileBytecode(compilerProbe))
    );
    const protocolSurface = String(hara.eval(surface));
    return {
      portable,
      capability,
      receivers,
      crossCutting,
      capabilityReceivers,
      nativeValues,
      predicates,
      interpreted,
      compiled,
      protocolSurface
    };
  }, { behavioral, surface, resources });

  for (const result of [
    observed.portable,
    observed.capability,
    observed.receivers,
    observed.crossCutting,
    observed.capabilityReceivers,
    observed.nativeValues,
    observed.predicates,
    observed.protocolSurface
  ]) {
    expect(result).not.toContain(":pass false");
    expect(passingResultCount(result)).toBeGreaterThan(0);
  }
  expect(observed.interpreted).toBe("true");
  expect(observed.compiled).toBe("true");
});