@telorun/assert 0.1.0

package/dist/manifest.js

@@ -0,0 +1,153 @@
+import { DEFAULT_MANIFEST_FILENAME, Loader, StaticAnalyzer, flattenForAnalyzer } from "@telorun/analyzer";
+import * as fs from "fs/promises";
+import * as path from "path";
+class LocalFileSource {
+    supports(p) {
+        return (p.startsWith("file://") ||
+            p.startsWith("/") ||
+            p.startsWith("./") ||
+            p.startsWith("../") ||
+            (!p.includes("://") && !p.includes("@")));
+    }
+    async read(p) {
+        const norm = p.startsWith("file://") ? new URL(p).pathname : p;
+        const resolved = path.resolve(norm);
+        const stat = await fs.stat(resolved);
+        const filePath = stat.isDirectory() ? path.join(resolved, DEFAULT_MANIFEST_FILENAME) : resolved;
+        const text = await fs.readFile(filePath, "utf-8");
+        return { text, source: `file://${filePath}` };
+    }
+    async readAll(p) {
+        const norm = p.startsWith("file://") ? new URL(p).pathname : p;
+        const resolved = path.resolve(norm);
+        const stat = await fs.stat(resolved);
+        if (stat.isDirectory()) {
+            const entries = await fs.readdir(resolved);
+            return entries
+                .filter((e) => e.endsWith(".yaml") || e.endsWith(".yml"))
+                .map((e) => `file://${path.join(resolved, e)}`);
+        }
+        return [`file://${resolved}`];
+    }
+    resolveRelative(base, relative) {
+        const basePath = base.startsWith("file://") ? new URL(base).pathname : base;
+        const baseDir = basePath.endsWith("/") ? basePath : path.dirname(basePath);
+        return `file://${path.resolve(baseDir, relative)}`;
+    }
+}
+function matchesDiagnostic(diag, expected) {
+    if (expected.code && diag.code !== expected.code)
+        return false;
+    if (expected.message && !diag.message.includes(expected.message))
+        return false;
+    return true;
+}
+export async function create(manifest, ctx) {
+    return {
+        run: async () => {
+            const useColor = ctx.stderr.isTTY ?? false;
+            const c = (code, text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+            const bold = (t) => c("1", t);
+            const red = (t) => c("31", t);
+            const green = (t) => c("32", t);
+            const dim = (t) => c("2", t);
+            const name = manifest.metadata.name;
+            const loader = new Loader([new LocalFileSource()]);
+            const analyzer = new StaticAnalyzer();
+            const resolvedUrl = new URL(manifest.source, ctx.moduleContext.source).toString();
+            let manifests;
+            try {
+                const graph = await loader.loadGraph(resolvedUrl);
+                if (graph.errors.length > 0)
+                    throw graph.errors[0].error;
+                manifests = flattenForAnalyzer(graph);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (manifest.expect.loadError) {
+                    if (errMsg.includes(manifest.expect.loadError)) {
+                        ctx.stdout.write(bold(green(`Assert.Manifest.${name}: assertion passed`)) +
+                            "\n  " + green("✓") + " " + dim(`load error: ${errMsg}`) + "\n");
+                    }
+                    else {
+                        ctx.stderr.write(bold(red(`Assert.Manifest.${name}: assertion failed`)) +
+                            "\n  " + red("✗") + ` expected load error containing "${manifest.expect.loadError}"` +
+                            "\n  " + dim(`actual: ${errMsg}`) + "\n");
+                        ctx.requestExit(1);
+                    }
+                    return;
+                }
+                ctx.stderr.write(bold(red(`Assert.Manifest.${name}: failed to load "${manifest.source}"`)) +
+                    "\n  " + errMsg + "\n");
+                ctx.requestExit(1);
+                return;
+            }
+            if (manifest.expect.loadError) {
+                ctx.stderr.write(bold(red(`Assert.Manifest.${name}: assertion failed`)) +
+                    "\n  " + red("✗") + ` expected load error containing "${manifest.expect.loadError}" but manifest loaded successfully\n`);
+                ctx.requestExit(1);
+                return;
+            }
+            const diagnostics = analyzer.analyze(manifests);
+            const errors = diagnostics.filter((d) => d.severity === 1); // DiagnosticSeverity.Error = 1
+            const warnings = diagnostics.filter((d) => d.severity === 2); // DiagnosticSeverity.Warning = 2
+            const expectedErrors = manifest.expect.errors ?? [];
+            const expectedWarnings = manifest.expect.warnings ?? [];
+            const failures = [];
+            const matched = [];
+            if (expectedErrors.length === 0) {
+                // Expect zero errors — any error is a failure
+                if (errors.length > 0) {
+                    for (const d of errors) {
+                        failures.push(`unexpected error: [${d.code}] ${d.message}`);
+                    }
+                }
+                else {
+                    matched.push("no errors");
+                }
+            }
+            else {
+                for (const expected of expectedErrors) {
+                    const match = errors.find((d) => matchesDiagnostic(d, expected));
+                    if (match) {
+                        matched.push(`${expected.code ?? "*"}${expected.message ? ` (${expected.message})` : ""}`);
+                    }
+                    else {
+                        failures.push(`expected error ${expected.code ?? "*"}${expected.message ? ` containing "${expected.message}"` : ""} — not found`);
+                    }
+                }
+            }
+            // Warnings are checked only when the caller declares expect.warnings. Unexpected
+            // warnings are not failures (unlike errors) — warnings are advisory and may exist
+            // on manifests that are otherwise valid. When expect.warnings is present, every
+            // listed warning must be found; extras are ignored.
+            if (expectedWarnings.length > 0) {
+                for (const expected of expectedWarnings) {
+                    const match = warnings.find((d) => matchesDiagnostic(d, expected));
+                    if (match) {
+                        matched.push(`warning ${expected.code ?? "*"}${expected.message ? ` (${expected.message})` : ""}`);
+                    }
+                    else {
+                        failures.push(`expected warning ${expected.code ?? "*"}${expected.message ? ` containing "${expected.message}"` : ""} — not found`);
+                    }
+                }
+            }
+            const passedLines = matched.map((m) => `  ${green("✓")} ${dim(m)}\n`).join("");
+            if (failures.length > 0) {
+                const failedLines = failures.map((f) => `  ${red("✗")} ${f}\n`).join("");
+                const actualLines = errors.length > 0 || warnings.length > 0
+                    ? `  ${dim("actual diagnostics:")}\n` +
+                        [...errors, ...warnings]
+                            .map((d) => `    ${dim(`[${d.code}] ${d.message}`)}\n`)
+                            .join("")
+                    : `  ${dim("no diagnostics produced")}\n`;
+                ctx.stderr.write(bold(red(`Assert.Manifest.${name}: assertion failed`)) + "\n" +
+                    passedLines + failedLines + actualLines);
+                ctx.requestExit(1);
+            }
+            else {
+                ctx.stdout.write(bold(green(`Assert.Manifest.${name}: assertion passed`)) + "\n" + passedLines);
+            }
+        },
+    };
+}

package/dist/matches.d.ts

@@ -0,0 +1,17 @@
+import { ResourceContext } from "@telorun/sdk";
+import { Static } from "@sinclair/typebox";
+export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
+}>;
+type AssertManifest = Static<typeof schema>;
+interface MatchesInput {
+    actual: unknown;
+    pattern: string;
+    flags?: string;
+}
+export declare function create(manifest: AssertManifest, ctx: ResourceContext): Promise<{
+    invoke: (input: MatchesInput) => boolean;
+}>;
+export {};

package/dist/matches.js

@@ -0,0 +1,45 @@
+import { InvokeError } from "@telorun/sdk";
+import { Type } from "@sinclair/typebox";
+import { createColors } from "./colors.js";
+export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+    }),
+});
+export async function create(manifest, ctx) {
+    const { bold, red, green, dim } = createColors(ctx);
+    const name = manifest.metadata.name;
+    return {
+        invoke: (input) => {
+            const { actual, pattern, flags } = input ?? {};
+            if (typeof pattern !== "string") {
+                throw new InvokeError("ERR_INVALID_CONFIG", `Assert.Matches "${name}": 'pattern' must be a string`);
+            }
+            let regex;
+            try {
+                regex = new RegExp(pattern, flags ?? "");
+            }
+            catch (err) {
+                throw new InvokeError("ERR_INVALID_CONFIG", `Assert.Matches "${name}": invalid pattern — ${err instanceof Error ? err.message : String(err)}`);
+            }
+            if (typeof actual !== "string") {
+                const message = `actual must be a string; got ${typeof actual}`;
+                ctx.stderr.write(bold(red(`Assert.Matches.${name}: assertion failed`)) +
+                    "\n" +
+                    `  ${red("✗")} ${message}\n`);
+                throw new InvokeError("ERR_ASSERTION_FAILED", `Assert.Matches "${name}": ${message}`);
+            }
+            if (regex.test(actual)) {
+                ctx.stdout.write(bold(green(`Assert.Matches.${name}: assertion passed`)) +
+                    "\n" +
+                    `  ${green("✓")} ${dim(JSON.stringify(actual))} ${dim("~")} ${dim(regex.toString())}\n`);
+                return true;
+            }
+            const message = `${JSON.stringify(actual)} does not match ${regex.toString()}`;
+            ctx.stderr.write(bold(red(`Assert.Matches.${name}: assertion failed`)) +
+                "\n" +
+                `  ${red("✗")} ${message}\n`);
+            throw new InvokeError("ERR_ASSERTION_FAILED", `Assert.Matches "${name}": ${message}`);
+        },
+    };
+}

package/dist/module-context.d.ts

@@ -0,0 +1,17 @@
+import { Static } from "@sinclair/typebox";
+import { ResourceContext, Runnable } from "@telorun/sdk";
+export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+        module: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    resources: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
+        variables: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+        secrets: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    }>>>;
+    variables: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+    secrets: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TAny>>;
+}>;
+type ModuleContextManifest = Static<typeof schema>;
+export declare function create(manifest: ModuleContextManifest, ctx: ResourceContext): Promise<Runnable>;
+export {};

package/dist/module-context.js

@@ -0,0 +1,89 @@
+import { Type } from "@sinclair/typebox";
+const ImportEntry = Type.Object({
+    variables: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    secrets: Type.Optional(Type.Record(Type.String(), Type.Any())),
+});
+export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+        module: Type.Optional(Type.String()),
+    }),
+    resources: Type.Optional(Type.Record(Type.String(), ImportEntry)),
+    variables: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    secrets: Type.Optional(Type.Record(Type.String(), Type.Any())),
+});
+function createColors(stream) {
+    const useColor = stream.isTTY ?? false;
+    const c = (code, text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+    return {
+        bold: (t) => c("1", t),
+        red: (t) => c("31", t),
+        green: (t) => c("32", t),
+        yellow: (t) => c("33", t),
+        dim: (t) => c("2", t),
+    };
+}
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+export async function create(manifest, ctx) {
+    return {
+        run: async () => {
+            const { bold, red, green, yellow, dim } = createColors(ctx.stderr);
+            const resourcesToCheck = manifest.resources ?? {};
+            const failures = [];
+            const passed = [];
+            const { resources } = ctx.moduleContext;
+            for (const [alias, expected] of Object.entries(resourcesToCheck)) {
+                if (!ctx.moduleContext.hasImport(alias)) {
+                    failures.push(`Import alias '${alias}' not found in declaring module`);
+                    continue;
+                }
+                const snap = resources[alias] ?? {};
+                const path = `resources.${alias}`;
+                for (const [key, expectedValue] of Object.entries(expected.variables ?? {})) {
+                    const actual = snap?.variables?.[key];
+                    if (deepEqual(actual, expectedValue)) {
+                        passed.push(`${path}.variables.${key}`);
+                    }
+                    else {
+                        failures.push(`${path}.variables.${key}: expected ${yellow(JSON.stringify(expectedValue))}, got ${red(JSON.stringify(actual))}`);
+                    }
+                }
+                for (const [key, expectedValue] of Object.entries(expected.secrets ?? {})) {
+                    const actual = snap?.secrets?.[key];
+                    if (deepEqual(actual, expectedValue)) {
+                        passed.push(`${path}.secrets.${key}`);
+                    }
+                    else {
+                        failures.push(`${path}.secrets.${key}: ${dim("value mismatch")}`);
+                    }
+                }
+            }
+            const name = manifest.metadata.name;
+            const passedLines = passed.map((p) => `  ${green("✓")} ${dim(p)}\n`).join("");
+            if (failures.length > 0) {
+                const failedLines = failures.map((f) => `  ${red("✗")} ${f}\n`).join("");
+                ctx.stderr.write(bold(red(`Assert.ModuleContext.${name}: assertion failed`)) + "\n" + passedLines + failedLines);
+                ctx.requestExit(1);
+            }
+            else {
+                ctx.stdout.write(bold(green(`Assert.ModuleContext.${name}: assertion passed`)) + "\n" + passedLines);
+            }
+        },
+    };
+}

package/dist/schema.d.ts

@@ -0,0 +1,15 @@
+import { ResourceContext } from "@telorun/sdk";
+import { Static } from "@sinclair/typebox";
+export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
+    schema: import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+    }>;
+}>;
+type AssertManifest = Static<typeof schema>;
+export declare function create(manifest: AssertManifest, ctx: ResourceContext): Promise<{
+    invoke: (data: any) => boolean;
+}>;
+export {};

package/dist/schema.js

@@ -0,0 +1,32 @@
+import { Type } from "@sinclair/typebox";
+export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+    }),
+    schema: Type.Object({
+        type: Type.String(),
+    }),
+});
+export async function create(manifest, ctx) {
+    const useColor = ctx.stderr.isTTY ?? false;
+    const c = (code, text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+    const bold = (t) => c("1", t);
+    const red = (t) => c("31", t);
+    const green = (t) => c("32", t);
+    const dim = (t) => c("2", t);
+    const validator = ctx.createSchemaValidator(manifest.schema);
+    const name = manifest.metadata.name;
+    return {
+        invoke: (data) => {
+            try {
+                validator.validate(data);
+                ctx.stdout.write(bold(green(`Assert.Schema.${name}: assertion passed`)) + "\n" + `  ${green("✓")} ${dim(JSON.stringify(data))}\n`);
+                return true;
+            }
+            catch (err) {
+                ctx.stderr.write(bold(red(`Assert.Schema.${name}: assertion failed`)) + "\n" + `  ${red("✗")} ${err?.message ?? String(err)}\n`);
+                throw err;
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@telorun/assert",
+  "version": "0.1.0",
+  "description": "Telo Assert module - Assertion resource kinds for Telo manifests.",
+  "keywords": [
+    "telo",
+    "assert",
+    "testing"
+  ],
+  "author": "Bartosz Pasiński <bartosz.pasinski@codenet.pl>",
+  "license": "SEE LICENSE IN LICENSE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/telorun/telo.git",
+    "directory": "modules/assert/nodejs"
+  },
+  "homepage": "https://github.com/telorun/telo#readme",
+  "bugs": {
+    "url": "https://github.com/telorun/telo/issues"
+  },
+  "type": "module",
+  "exports": {
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "bun": "./src/schema.ts",
+      "import": "./dist/schema.js"
+    },
+    "./events": {
+      "types": "./dist/events.d.ts",
+      "bun": "./src/events.ts",
+      "import": "./dist/events.js"
+    },
+    "./module-context": {
+      "types": "./dist/module-context.d.ts",
+      "bun": "./src/module-context.ts",
+      "import": "./dist/module-context.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "bun": "./src/manifest.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./equals": {
+      "types": "./dist/equals.d.ts",
+      "bun": "./src/equals.ts",
+      "import": "./dist/equals.js"
+    },
+    "./matches": {
+      "types": "./dist/matches.d.ts",
+      "bun": "./src/matches.ts",
+      "import": "./dist/matches.js"
+    },
+    "./contains": {
+      "types": "./dist/contains.d.ts",
+      "bun": "./src/contains.ts",
+      "import": "./dist/contains.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**"
+  ],
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.48",
+    "@telorun/analyzer": "0.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@telorun/sdk": "0.12.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  }
+}

package/src/colors.ts

@@ -0,0 +1,18 @@
+import type { ResourceContext } from "@telorun/sdk";
+
+/**
+ * Build the small ANSI color helpers used by every assert kind. Returns
+ * pass-through (uncolored) helpers when stderr isn't a TTY so piped /
+ * redirected output stays clean.
+ */
+export function createColors(ctx: ResourceContext) {
+  const useColor = (ctx.stderr as { isTTY?: boolean }).isTTY ?? false;
+  const c = (code: string, text: string) =>
+    useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+  return {
+    bold: (t: string) => c("1", t),
+    red: (t: string) => c("31", t),
+    green: (t: string) => c("32", t),
+    dim: (t: string) => c("2", t),
+  };
+}

package/src/contains.ts

@@ -0,0 +1,74 @@
+import { InvokeError, ResourceContext } from "@telorun/sdk";
+import { Static, Type } from "@sinclair/typebox";
+import { createColors } from "./colors.js";
+import { deepEquals } from "./deep-equals.js";
+
+export const schema = Type.Object({
+  metadata: Type.Object({
+    name: Type.String(),
+  }),
+});
+
+type AssertManifest = Static<typeof schema>;
+
+interface ContainsInput {
+  actual: unknown;
+  value: unknown;
+}
+
+export async function create(manifest: AssertManifest, ctx: ResourceContext) {
+  const { bold, red, green, dim } = createColors(ctx);
+  const name = manifest.metadata.name;
+
+  return {
+    invoke: (input: ContainsInput) => {
+      const { actual, value } = input ?? ({} as ContainsInput);
+
+      let ok = false;
+      let kind = "";
+      if (typeof actual === "string") {
+        if (typeof value !== "string") {
+          const message = `actual is a string but value is ${typeof value}; expected substring`;
+          ctx.stderr.write(
+            bold(red(`Assert.Contains.${name}: assertion failed`)) +
+              "\n" +
+              `  ${red("✗")} ${message}\n`,
+          );
+          throw new InvokeError(
+            "ERR_ASSERTION_FAILED",
+            `Assert.Contains "${name}": ${message}`,
+          );
+        }
+        kind = "substring";
+        ok = actual.includes(value);
+      } else if (Array.isArray(actual)) {
+        kind = "element";
+        ok = actual.some((item) => deepEquals(item, value));
+      } else {
+        const message = `actual must be string or array; got ${typeof actual}`;
+        ctx.stderr.write(
+          bold(red(`Assert.Contains.${name}: assertion failed`)) +
+            "\n" +
+            `  ${red("✗")} ${message}\n`,
+        );
+        throw new InvokeError("ERR_ASSERTION_FAILED", `Assert.Contains "${name}": ${message}`);
+      }
+
+      if (ok) {
+        ctx.stdout.write(
+          bold(green(`Assert.Contains.${name}: assertion passed`)) +
+            "\n" +
+            `  ${green("✓")} ${dim(JSON.stringify(actual))} ${dim("⊇")} ${dim(JSON.stringify(value))}\n`,
+        );
+        return true;
+      }
+      const message = `${JSON.stringify(actual)} does not contain ${kind} ${JSON.stringify(value)}`;
+      ctx.stderr.write(
+        bold(red(`Assert.Contains.${name}: assertion failed`)) +
+          "\n" +
+          `  ${red("✗")} ${message}\n`,
+      );
+      throw new InvokeError("ERR_ASSERTION_FAILED", `Assert.Contains "${name}": ${message}`);
+    },
+  };
+}

package/src/deep-equals.ts

@@ -0,0 +1,45 @@
+/**
+ * Deep equality for the JSON-shaped values Telo stages typically pass
+ * around: primitives, plain objects (proto === Object.prototype or null),
+ * and arrays. Non-plain objects (Date, Map, Set, RegExp, class instances)
+ * are NOT structurally compared — only `Object.is`-equal instances pass.
+ *
+ * This is intentional: structurally comparing the empty `Object.keys()`
+ * of two distinct `new Date(…)` instances would silently return true,
+ * letting `Assert.Equals` pass for values that are clearly different.
+ * If a consumer genuinely needs Date / Map / Set equality, they should
+ * serialize first (e.g. `date.toISOString()`) and compare the strings.
+ */
+export function deepEquals(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEquals(a[i], b[i])) return false;
+    }
+    return true;
+  }
+
+  // Refuse structural compare for non-plain objects. Identity was already
+  // checked at the top; reaching here with a non-plain object means a !== b
+  // and we cannot meaningfully recurse into "fields" — empty keys would
+  // produce false positives.
+  if (!isPlainObject(a) || !isPlainObject(b)) return false;
+
+  const ao = a as Record<string, unknown>;
+  const bo = b as Record<string, unknown>;
+  const aKeys = Object.keys(ao);
+  const bKeys = Object.keys(bo);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const k of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(bo, k) || !deepEquals(ao[k], bo[k])) return false;
+  }
+  return true;
+}
+
+function isPlainObject(v: object): boolean {
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}

package/src/equals.ts

@@ -0,0 +1,43 @@
+import { InvokeError, ResourceContext } from "@telorun/sdk";
+import { Static, Type } from "@sinclair/typebox";
+import { createColors } from "./colors.js";
+import { deepEquals } from "./deep-equals.js";
+
+export const schema = Type.Object({
+  metadata: Type.Object({
+    name: Type.String(),
+  }),
+});
+
+type AssertManifest = Static<typeof schema>;
+
+interface EqualsInput {
+  actual: unknown;
+  expected: unknown;
+}
+
+export async function create(manifest: AssertManifest, ctx: ResourceContext) {
+  const { bold, red, green, dim } = createColors(ctx);
+  const name = manifest.metadata.name;
+
+  return {
+    invoke: (input: EqualsInput) => {
+      const { actual, expected } = input ?? ({} as EqualsInput);
+      if (deepEquals(actual, expected)) {
+        ctx.stdout.write(
+          bold(green(`Assert.Equals.${name}: assertion passed`)) +
+            "\n" +
+            `  ${green("✓")} ${dim(JSON.stringify(actual))}\n`,
+        );
+        return true;
+      }
+      const message = `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`;
+      ctx.stderr.write(
+        bold(red(`Assert.Equals.${name}: assertion failed`)) +
+          "\n" +
+          `  ${red("✗")} ${message}\n`,
+      );
+      throw new InvokeError("ERR_ASSERTION_FAILED", `Assert.Equals "${name}": ${message}`);
+    },
+  };
+}