@lionlang/core 0.1.0 → 0.2.0

package/README.md

@@ -1,15 +1,335 @@
-# @lionlang/core
+# Lion
 
-To install dependencies:
+Lion is a JSON-based Lisp. Every Lion program is valid JSON, which makes it easy to serialize, store, inspect, and generate from other systems.
+
+The evaluator runs on Effect v4.
+
+Lion evaluates:
+
+- JSON primitives directly
+- strings as environment references when a binding exists
+- arrays as special forms or function-call expressions
+- objects by recursively evaluating their values
+
+The result is a small homoiconic language that can describe both computation and data interchange without a separate parser.
+
+## Packages
+
+```text
+packages/
+  core/   evaluator, special forms, stdlib
+  repl/   interactive web REPL
+  agent/  real-world Lion program driving an OpenTUI + AI agent
+```
+
+## Basic Usage
+
+```ts
+import { Effect } from "effect";
+import { run } from "@lionlang/core/evaluation/evaluate";
+import { stdlib } from "@lionlang/core/modules";
+
+const result = await Effect.runPromise(
+	run(["number/add", 1, 2], stdlib)
+);
+
+// => 3
+```
+
+## Custom Environment
+
+Any string can resolve against the evaluation environment. That includes values, objects, classes, and functions.
+
+```ts
+import { Effect } from "effect";
+import { run } from "@lionlang/core/evaluation/evaluate";
+import { stdlib } from "@lionlang/core/modules";
+
+const env = {
+	...stdlib,
+	price: 100,
+	taxRate: 0.08,
+	clamp: (min: number, max: number, value: number) =>
+		Math.min(max, Math.max(min, value)),
+};
+
+await Effect.runPromise(
+	run(["number/add", "price", ["number/multiply", "price", "taxRate"]], env)
+);
+// => 108
+
+await Effect.runPromise(run(["clamp", 0, 100, 150], env));
+// => 100
+```
+
+## Expression Model
+
+### Primitives
+
+Numbers, booleans, and `null` evaluate to themselves. Strings are treated as references first; if no binding exists, the original string is returned.
+
+```json
+42
+true
+null
+"x"
+```
+
+With `{ "x": 10 }` in the environment, `"x"` evaluates to `10`. Otherwise it evaluates to `"x"`.
+
+### Arrays
+
+Arrays are always treated as executable expressions:
+
+1. special forms such as `["define", "x", 1]`
+2. function calls when the first element evaluates to a function
+
+```json
+["number/add", 1, 2]
+```
+
+Evaluates to `3`.
+
+### Objects
+
+Objects preserve their keys and evaluate each value.
+
+```json
+{
+  "sum": ["number/add", 1, 2],
+  "ok": true
+}
+```
+
+Evaluates to `{ "sum": 3, "ok": true }`.
+
+## Special Forms
+
+### `quote`
+
+Returns its argument without evaluating it.
+
+```json
+["quote", ["number/add", 1, 2]]
+```
+
+### `eval`
+
+Evaluates its argument, then evaluates the result.
+
+```json
+["eval", ["quote", ["number/add", 1, 2]]]
+```
+
+### `begin`
+
+Evaluates expressions in order and returns the last result.
+
+```json
+["begin", ["define", "x", 1], ["define", "x", 2], "x"]
+```
+
+### `define`
+
+Evaluates a value, stores it in the global environment, and returns the stored value.
+
+```json
+["define", "answer", 42]
+```
+
+### `lambda`
+
+Creates a Lion function with lexical scope.
+
+```json
+["lambda", ["x"], ["number/add", "x", 1]]
+```
+
+Lambdas close over surrounding scope, and they observe updated global bindings when invoked later.
+
+### `cond`
+
+Evaluates condition/result pairs in order and returns the first matching result. An `else` branch is optional.
+
+```json
+["cond",
+  [["number/greaterThan", "score", 90], "great"],
+  [["number/greaterThan", "score", 70], "pass"],
+  ["else", "retry"]]
+```
+
+If no branch matches and no `else` is provided, `cond` returns `null`.
+
+### `match`
+
+Pattern matches a value against predicate/function pairs, then applies the first matching branch. The last argument is a fallback function.
+
+```json
+["match",
+  "value",
+  ["value/number?", ["lambda", ["x"], ["number/add", "x", 1]]],
+  ["value/string?", ["lambda", ["x"], ["string/concat", "x", "!"]]],
+  ["lambda", ["x"], "x"]]
+```
+
+`match` also supports structural predicates:
+
+```json
+["match",
+  { "type": "user", "profile": { "name": "Ada" } },
+  [
+    {
+      "type": ["func/partial", "string/equals?", "user"],
+      "profile": { "name": "value/string?" }
+    },
+    "value/identity"
+  ],
+  ["lambda", ["x"], null]]
+```
+
+## Standard Library
+
+The default environment exported as `stdlib` namespaces entries as `<module>/<name>`.
+
+### `number`
+
+```json
+["number/add", 1, 2]
+["number/subtract", 10, 3]
+["number/multiply", 5, 4]
+["number/divide", 20, 4]
+["number/equals?", 5, 5]
+["number/lessThan", 3, 5]
+["number/greaterThan", 5, 3]
+["number/lessThanOrEqualTo", 3, 5]
+["number/greaterThanOrEqualTo", 5, 5]
+```
+
+### `boolean`
+
+```json
+["boolean/not", true]
+["boolean/and", true, false]
+["boolean/or", false, true]
+["boolean/xor", true, false]
+["boolean/nand", true, true]
+["boolean/nor", false, false]
+["boolean/equals?", true, true]
+```
+
+### `array`
+
+```json
+["array/make", 1, 2, 3]
+["array/head", ["array/make", 1, 2, 3]]
+["array/tail", ["array/make", 1, 2, 3]]
+["array/length", ["array/make", 1, 2, 3]]
+["array/concat", ["array/make", 1, 2], ["array/make", 3, 4]]
+["array/includes?", ["array/make", 1, 2, 3], 2]
+["array/map", ["array/make", 1, 2, 3], ["lambda", ["x"], ["number/add", "x", 1]]]
+["array/flat-map", ["array/make", 1, 2], ["lambda", ["x"], ["array/make", "x", "x"]]]
+["array/reduce", ["array/make", 1, 2, 3], 0, ["lambda", ["acc", "x"], ["number/add", "acc", "x"]]]
+```
+
+### `string`
+
+```json
+["string/equals?", "a", "a"]
+["string/length", "lion"]
+["string/concat", "lion", "ized"]
+["string/startsWith", "lion", "li"]
+["string/endsWith", "lion", "on"]
+["string/includes", "lion", "io"]
+["string/indexOf", "lion", "o"]
+```
+
+### `object`
+
+```json
+["object/get", {"a": 1}, "a"]
+["object/get-path", {"a": {"b": {"c": 42}}}, "a.b.c"]
+["object/keys", {"a": 1, "b": 2}]
+["object/values", {"a": 1, "b": 2}]
+["object/json-stringify", {"a": 1}, null, 2]
+["object/get-method", "obj", "methodName"]
+["object/call-method", "obj", "methodName", 1, 2]
+["object/get-method-path", "obj", "nested.methodName"]
+["object/call-method-path", "obj", "nested.methodName", 1, 2]
+["object/new", "SomeClass", "arg1", "arg2"]
+```
+
+`object/get-path` understands dot paths and numeric array segments such as `"users.1.name"`.
+
+### `func`
+
+```json
+["func/bind", "fn", "obj"]
+["func/apply", "fn", "obj", 1, 2]
+["func/callback", ["lambda", ["x"], ["number/add", "x", 1]]]
+["func/partial", "fn", 1, 2]
+```
+
+`func/callback` is especially useful for turning Lion lambdas into JavaScript callbacks while preserving access to the Lion environment.
+
+### `value`
+
+```json
+["value/function?", "x"]
+["value/number?", 1]
+["value/string?", "lion"]
+["value/boolean?", true]
+["value/object?", {"a": 1}]
+["value/array?", ["array/make", 1, 2]]
+["value/null?", null]
+["value/identity", 42]
+```
+
+`value/undefined?` and `value/symbol?` are mainly useful when Lion is evaluating host values supplied through the environment.
+
+### `console`
+
+```json
+["console/log", "hello"]
+["console/log-json", {"hello": "world"}]
+```
+
+## Host Interop
+
+Lion works well as a configuration and orchestration layer over ordinary JavaScript objects and functions.
+
+The `packages/agent` package is the clearest example. It injects:
+
+- `OpenTUI` classes and enums
+- AI SDK helpers
+- a model instance
+- Node `fs`
+- Zod constructors
+- a renderer instance
+
+Then Lion code in [`packages/agent/src/agent.json`](/Users/andrueanderson/Workspace/TypeScript/lion/packages/agent/src/agent.json) uses:
+
+- `object/get-path` to traverse host APIs
+- `object/new` to construct classes
+- `object/call-method` via aliases such as `"()"`
+- `func/callback` to hand Lion lambdas to promise and event APIs
+- `match`, `cond`, `begin`, and `define` to orchestrate application flow
+
+That lets Lion drive a non-trivial terminal UI agent entirely from JSON.
+
+## Development
+
+From the repo root:
 
 ```bash
 bun install
+bun run prepare
+bun test
+bun run build
 ```
 
-To run:
+To work on a specific package:
 
 ```bash
-bun run index.ts
+turbo test --filter=@lionlang/core
+turbo dev --filter=@lionlang/repl
 ```
-
-This project was created using `bun init` in bun v1.3.1. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/analysis/analyze.d.mts

@@ -0,0 +1,34 @@
+import { a as LionExpressionType } from "../lion-expression-DMR7Psmu.mjs";
+
+//#region src/analysis/analyze.d.ts
+type StructuralPath = readonly (number | string)[];
+type SemanticKind = "primitive" | "record" | "array" | "empty-array" | "call" | "special-form" | "invalid-call";
+type SpecialFormName = "begin" | "cond" | "define" | "eval" | "lambda" | "match" | "quote";
+interface SemanticRelationship {
+  readonly kind: "definition" | "reference-candidate";
+  readonly name: string;
+}
+interface SemanticChild {
+  readonly node: SemanticNode;
+  readonly order: number;
+  readonly role: string;
+}
+interface SemanticNode {
+  readonly children: readonly SemanticChild[];
+  readonly diagnostic?: string;
+  readonly kind: SemanticKind;
+  readonly label: string;
+  readonly path: StructuralPath;
+  readonly pointer: string;
+  readonly quoted: boolean;
+  readonly relationships: readonly SemanticRelationship[];
+  readonly specialForm?: SpecialFormName;
+  readonly value?: boolean | null | number | string;
+}
+declare const pathToPointer: (path: StructuralPath) => string;
+declare const isSpecialFormName: (value: unknown) => value is SpecialFormName;
+declare const analyze: (expression: LionExpressionType) => SemanticNode;
+declare const flattenAnalysis: (root: SemanticNode) => readonly SemanticNode[];
+//#endregion
+export { SemanticChild, SemanticKind, SemanticNode, SemanticRelationship, SpecialFormName, StructuralPath, analyze, flattenAnalysis, isSpecialFormName, pathToPointer };
+//# sourceMappingURL=analyze.d.mts.map

package/dist/analysis/analyze.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.mts","names":[],"sources":["../../src/analysis/analyze.ts"],"mappings":";;;KAYY,cAAA;AAAA,KAEA,YAAA;AAAA,KASA,eAAA;AAAA,UASK,oBAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,aAAA;EAAA,SACN,IAAA,EAAM,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,YAAA;EAAA,SACN,QAAA,WAAmB,aAAA;EAAA,SACnB,UAAA;EAAA,SACA,IAAA,EAAM,YAAA;EAAA,SACN,KAAA;EAAA,SACA,IAAA,EAAM,cAAA;EAAA,SACN,OAAA;EAAA,SACA,MAAA;EAAA,SACA,aAAA,WAAwB,oBAAA;EAAA,SACxB,WAAA,GAAc,eAAA;EAAA,SACd,KAAA;AAAA;AAAA,cAwEE,aAAA,GAAiB,IAAA,EAAM,cAAA;AAAA,cA4IvB,iBAAA,GAAqB,KAAA,cAAiB,KAAA,IAAS,eAAA;AAAA,cAI/C,OAAA,GAAW,UAAA,EAAY,kBAAA,KAAqB,YAAA;AAAA,cAG5C,eAAA,GACX,IAAA,EAAM,YAAA,cACI,YAAA"}

package/dist/analysis/analyze.mjs

@@ -0,0 +1,181 @@
+import { BeginFormSchema, CondFormSchema, DefineFormSchema, EvalFormSchema, LambdaFormSchema, MatchFormSchema, QuoteFormSchema } from "../schemas/evaluation.mjs";
+import { Schema } from "effect";
+//#region src/analysis/analyze.ts
+const roleByIndex = (roles, fallback) => (index) => roles[index] ?? fallback;
+const SPECIAL_FORMS = [
+	{
+		name: "eval",
+		matches: Schema.is(EvalFormSchema),
+		role: roleByIndex(["operator", "expression"], "argument")
+	},
+	{
+		name: "quote",
+		matches: Schema.is(QuoteFormSchema),
+		role: roleByIndex(["operator", "quoted-value"], "quoted-value")
+	},
+	{
+		name: "begin",
+		matches: Schema.is(BeginFormSchema),
+		role: roleByIndex(["operator"], "sequence-item")
+	},
+	{
+		name: "define",
+		matches: Schema.is(DefineFormSchema),
+		role: roleByIndex([
+			"operator",
+			"binding",
+			"value"
+		], "value")
+	},
+	{
+		name: "lambda",
+		matches: Schema.is(LambdaFormSchema),
+		role: roleByIndex([
+			"operator",
+			"parameters",
+			"body"
+		], "body")
+	},
+	{
+		name: "cond",
+		matches: Schema.is(CondFormSchema),
+		role: roleByIndex(["operator"], "branch")
+	},
+	{
+		name: "match",
+		matches: Schema.is(MatchFormSchema),
+		role: (index, length) => {
+			if (index === 0) return "operator";
+			if (index === 1) return "subject";
+			return index === length - 1 ? "fallback" : "pattern";
+		}
+	}
+];
+const SPECIAL_FORM_NAMES = {
+	begin: true,
+	cond: true,
+	define: true,
+	eval: true,
+	lambda: true,
+	match: true,
+	quote: true
+};
+const escapePointerSegment = (segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
+const pathToPointer = (path) => path.length === 0 ? "" : `/${path.map(escapePointerSegment).join("/")}`;
+const primitiveLabel = (value) => {
+	if (typeof value === "string") return JSON.stringify(value);
+	return String(value);
+};
+const analyzeNode = (expression, path, quoted) => {
+	if (!Array.isArray(expression) && (expression === null || typeof expression !== "object")) {
+		const relationships = [];
+		if (typeof expression === "string") relationships.push({
+			kind: "reference-candidate",
+			name: expression
+		});
+		return {
+			path,
+			pointer: pathToPointer(path),
+			kind: "primitive",
+			label: primitiveLabel(expression),
+			value: expression,
+			quoted,
+			children: [],
+			relationships
+		};
+	}
+	if (!Array.isArray(expression)) {
+		const entries = Object.entries(expression);
+		return {
+			path,
+			pointer: pathToPointer(path),
+			kind: "record",
+			label: entries.length === 0 ? "empty record" : `record · ${entries.length}`,
+			quoted,
+			children: entries.map(([key, value], order) => ({
+				role: key,
+				order,
+				node: analyzeNode(value, [...path, key], quoted)
+			})),
+			relationships: []
+		};
+	}
+	if (expression.length === 0) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "empty-array",
+		label: "empty array",
+		quoted,
+		children: [],
+		relationships: []
+	};
+	const head = expression[0];
+	const namedForm = SPECIAL_FORMS.find(({ name }) => name === head);
+	const validForm = SPECIAL_FORMS.find(({ matches }) => matches(expression));
+	const relationships = [];
+	if (!quoted && validForm?.name === "define" && typeof expression[1] === "string") relationships.push({
+		kind: "definition",
+		name: expression[1]
+	});
+	const role = quoted ? () => "item" : validForm?.role ?? roleByIndex(["callee"], "argument");
+	const children = expression.map((value, order) => ({
+		role: role(order, expression.length),
+		order,
+		node: analyzeNode(value, [...path, order], quoted || validForm?.name === "quote" && order > 0)
+	}));
+	if (quoted) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "array",
+		label: `array · ${expression.length}`,
+		quoted,
+		children,
+		relationships
+	};
+	if (!quoted && namedForm && !validForm) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "invalid-call",
+		label: `invalid ${namedForm.name}`,
+		specialForm: namedForm.name,
+		quoted,
+		children,
+		relationships,
+		diagnostic: `The ${namedForm.name} form has an invalid structure.`
+	};
+	if (!quoted && validForm) return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "special-form",
+		label: validForm.name,
+		specialForm: validForm.name,
+		quoted,
+		children,
+		relationships
+	};
+	const label = typeof head === "string" ? head : "call";
+	return {
+		path,
+		pointer: pathToPointer(path),
+		kind: "call",
+		label,
+		quoted,
+		children,
+		relationships
+	};
+};
+const isSpecialFormName = (value) => typeof value === "string" && Object.hasOwn(SPECIAL_FORM_NAMES, value);
+const analyze = (expression) => analyzeNode(expression, [], false);
+const flattenAnalysis = (root) => {
+	const nodes = [];
+	const visit = (node) => {
+		nodes.push(node);
+		for (const child of node.children) visit(child.node);
+	};
+	visit(root);
+	return nodes;
+};
+//#endregion
+export { analyze, flattenAnalysis, isSpecialFormName, pathToPointer };
+
+//# sourceMappingURL=analyze.mjs.map

package/dist/analysis/analyze.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.mjs","names":[],"sources":["../../src/analysis/analyze.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport {\n  BeginFormSchema,\n  CondFormSchema,\n  DefineFormSchema,\n  EvalFormSchema,\n  LambdaFormSchema,\n  MatchFormSchema,\n  QuoteFormSchema,\n} from \"@/schemas/evaluation\";\nimport type { LionExpressionType } from \"@/schemas/lion-expression\";\n\nexport type StructuralPath = readonly (number | string)[];\n\nexport type SemanticKind =\n  | \"primitive\"\n  | \"record\"\n  | \"array\"\n  | \"empty-array\"\n  | \"call\"\n  | \"special-form\"\n  | \"invalid-call\";\n\nexport type SpecialFormName =\n  | \"begin\"\n  | \"cond\"\n  | \"define\"\n  | \"eval\"\n  | \"lambda\"\n  | \"match\"\n  | \"quote\";\n\nexport interface SemanticRelationship {\n  readonly kind: \"definition\" | \"reference-candidate\";\n  readonly name: string;\n}\n\nexport interface SemanticChild {\n  readonly node: SemanticNode;\n  readonly order: number;\n  readonly role: string;\n}\n\nexport interface SemanticNode {\n  readonly children: readonly SemanticChild[];\n  readonly diagnostic?: string;\n  readonly kind: SemanticKind;\n  readonly label: string;\n  readonly path: StructuralPath;\n  readonly pointer: string;\n  readonly quoted: boolean;\n  readonly relationships: readonly SemanticRelationship[];\n  readonly specialForm?: SpecialFormName;\n  readonly value?: boolean | null | number | string;\n}\n\ninterface FormDefinition {\n  readonly matches: (value: unknown) => boolean;\n  readonly name: SpecialFormName;\n  readonly role: (index: number, length: number) => string;\n}\n\nconst roleByIndex =\n  (roles: readonly string[], fallback: string) => (index: number) =>\n    roles[index] ?? fallback;\n\nconst SPECIAL_FORMS: readonly FormDefinition[] = [\n  {\n    name: \"eval\",\n    matches: Schema.is(EvalFormSchema),\n    role: roleByIndex([\"operator\", \"expression\"], \"argument\"),\n  },\n  {\n    name: \"quote\",\n    matches: Schema.is(QuoteFormSchema),\n    role: roleByIndex([\"operator\", \"quoted-value\"], \"quoted-value\"),\n  },\n  {\n    name: \"begin\",\n    matches: Schema.is(BeginFormSchema),\n    role: roleByIndex([\"operator\"], \"sequence-item\"),\n  },\n  {\n    name: \"define\",\n    matches: Schema.is(DefineFormSchema),\n    role: roleByIndex([\"operator\", \"binding\", \"value\"], \"value\"),\n  },\n  {\n    name: \"lambda\",\n    matches: Schema.is(LambdaFormSchema),\n    role: roleByIndex([\"operator\", \"parameters\", \"body\"], \"body\"),\n  },\n  {\n    name: \"cond\",\n    matches: Schema.is(CondFormSchema),\n    role: roleByIndex([\"operator\"], \"branch\"),\n  },\n  {\n    name: \"match\",\n    matches: Schema.is(MatchFormSchema),\n    role: (index, length) => {\n      if (index === 0) {\n        return \"operator\";\n      }\n      if (index === 1) {\n        return \"subject\";\n      }\n      return index === length - 1 ? \"fallback\" : \"pattern\";\n    },\n  },\n];\n\nconst SPECIAL_FORM_NAMES: Readonly<Record<SpecialFormName, true>> = {\n  begin: true,\n  cond: true,\n  define: true,\n  eval: true,\n  lambda: true,\n  match: true,\n  quote: true,\n};\n\nconst escapePointerSegment = (segment: number | string) =>\n  String(segment).replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n\nexport const pathToPointer = (path: StructuralPath): string =>\n  path.length === 0 ? \"\" : `/${path.map(escapePointerSegment).join(\"/\")}`;\n\nconst primitiveLabel = (value: boolean | null | number | string) => {\n  if (typeof value === \"string\") {\n    return JSON.stringify(value);\n  }\n  return String(value);\n};\n\nconst analyzeNode = (\n  expression: LionExpressionType,\n  path: StructuralPath,\n  quoted: boolean\n): SemanticNode => {\n  if (\n    !Array.isArray(expression) &&\n    (expression === null || typeof expression !== \"object\")\n  ) {\n    const relationships: SemanticRelationship[] = [];\n    if (typeof expression === \"string\") {\n      relationships.push({ kind: \"reference-candidate\", name: expression });\n    }\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"primitive\",\n      label: primitiveLabel(expression),\n      value: expression,\n      quoted,\n      children: [],\n      relationships,\n    };\n  }\n\n  if (!Array.isArray(expression)) {\n    const entries = Object.entries(expression);\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"record\",\n      label:\n        entries.length === 0 ? \"empty record\" : `record · ${entries.length}`,\n      quoted,\n      children: entries.map(([key, value], order) => ({\n        role: key,\n        order,\n        node: analyzeNode(value, [...path, key], quoted),\n      })),\n      relationships: [],\n    };\n  }\n\n  if (expression.length === 0) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"empty-array\",\n      label: \"empty array\",\n      quoted,\n      children: [],\n      relationships: [],\n    };\n  }\n\n  const head = expression[0];\n  const namedForm = SPECIAL_FORMS.find(({ name }) => name === head);\n  const validForm = SPECIAL_FORMS.find(({ matches }) => matches(expression));\n  const relationships: SemanticRelationship[] = [];\n  if (\n    !quoted &&\n    validForm?.name === \"define\" &&\n    typeof expression[1] === \"string\"\n  ) {\n    relationships.push({ kind: \"definition\", name: expression[1] });\n  }\n  const role = quoted\n    ? () => \"item\"\n    : (validForm?.role ?? roleByIndex([\"callee\"], \"argument\"));\n  const children = expression.map((value, order) => ({\n    role: role(order, expression.length),\n    order,\n    node: analyzeNode(\n      value,\n      [...path, order],\n      quoted || (validForm?.name === \"quote\" && order > 0)\n    ),\n  }));\n\n  if (quoted) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"array\",\n      label: `array · ${expression.length}`,\n      quoted,\n      children,\n      relationships,\n    };\n  }\n\n  if (!quoted && namedForm && !validForm) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"invalid-call\",\n      label: `invalid ${namedForm.name}`,\n      specialForm: namedForm.name,\n      quoted,\n      children,\n      relationships,\n      diagnostic: `The ${namedForm.name} form has an invalid structure.`,\n    };\n  }\n\n  if (!quoted && validForm) {\n    return {\n      path,\n      pointer: pathToPointer(path),\n      kind: \"special-form\",\n      label: validForm.name,\n      specialForm: validForm.name,\n      quoted,\n      children,\n      relationships,\n    };\n  }\n\n  const label = typeof head === \"string\" ? head : \"call\";\n  return {\n    path,\n    pointer: pathToPointer(path),\n    kind: \"call\",\n    label,\n    quoted,\n    children,\n    relationships,\n  };\n};\n\nexport const isSpecialFormName = (value: unknown): value is SpecialFormName =>\n  typeof value === \"string\" &&\n  Object.hasOwn(SPECIAL_FORM_NAMES, value as SpecialFormName);\n\nexport const analyze = (expression: LionExpressionType): SemanticNode =>\n  analyzeNode(expression, [], false);\n\nexport const flattenAnalysis = (\n  root: SemanticNode\n): readonly SemanticNode[] => {\n  const nodes: SemanticNode[] = [];\n  const visit = (node: SemanticNode) => {\n    nodes.push(node);\n    for (const child of node.children) {\n      visit(child.node);\n    }\n  };\n  visit(root);\n  return nodes;\n};\n"],"mappings":"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"}

package/dist/environment-BQw8BPXl.d.mts

@@ -0,0 +1,25 @@
+import { Ref, Schema } from "effect";
+
+//#region src/schemas/environment.d.ts
+type BindingsRef = Ref.Ref<Record<string, unknown>>;
+interface InnerEnvironment {
+  readonly bindingsRef: BindingsRef;
+  readonly parent: Environment;
+}
+type Environment = typeof EnvironmentSchema.Type;
+type ToplevelEnvironment = typeof ToplevelEnvironmentSchema.Type;
+declare const ToplevelEnvironmentSchema: Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+}>;
+declare const EnvironmentSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+}>, Schema.suspend<Schema.Codec<InnerEnvironment, InnerEnvironment, never, never>>]>;
+declare const InnerEnvironmentSchema: Schema.Struct<{
+  readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+  readonly parent: Schema.Union<readonly [Schema.Struct<{
+    readonly bindingsRef: Schema.Codec<BindingsRef, BindingsRef, never, never>;
+  }>, Schema.suspend<Schema.Codec<InnerEnvironment, InnerEnvironment, never, never>>]>;
+}>;
+//#endregion
+export { ToplevelEnvironment as a, InnerEnvironmentSchema as i, EnvironmentSchema as n, ToplevelEnvironmentSchema as o, InnerEnvironment as r, Environment as t };
+//# sourceMappingURL=environment-BQw8BPXl.d.mts.map

package/dist/{environment-k2Uf6VVc.d.mts.map → environment-BQw8BPXl.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"environment-k2Uf6VVc.d.mts","names":[],"sources":["../src/schemas/environment.ts"],"mappings":";;;KAEK,WAAA,GAAc,GAAA,CAAI,GAAA,CAAI,MAAA;AAAA,UAQV,gBAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGP,WAAA,UAAqB,iBAAA,CAAkB,IAAA;AAAA,KAEvC,mBAAA,UAA6B,yBAAA,CAA0B,IAAA;AAAA,cAEtD,yBAAA,EAAyB,MAAA,CAAA,MAAA;;;cAIzB,iBAAA,EAAiB,MAAA,CAAA,KAAA,EAAA,MAAA,CAAA,MAAA;;;cAKjB,sBAAA,EAAsB,MAAA,CAAA,MAAA"}
+{"version":3,"file":"environment-BQw8BPXl.d.mts","names":[],"sources":["../src/schemas/environment.ts"],"mappings":";;;KAEK,WAAA,GAAc,GAAA,CAAI,GAAA,CAAI,MAAA;AAAA,UAQV,gBAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,MAAA,EAAQ,WAAA;AAAA;AAAA,KAGP,WAAA,UAAqB,iBAAA,CAAkB,IAAA;AAAA,KAEvC,mBAAA,UAA6B,yBAAA,CAA0B,IAAA;AAAA,cAEtD,yBAAA,EAAyB,MAAA,CAAA,MAAA;EAAA;;cAIzB,iBAAA,EAAiB,MAAA,CAAA,KAAA,WAAA,MAAA,CAAA,MAAA;EAAA;;cAKjB,sBAAA,EAAsB,MAAA,CAAA,MAAA;EAAA"}

package/dist/errors/evaluation.d.mts

@@ -1,2 +1,2 @@
-import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-AblffSQw.mjs";
+import { n as InvalidFunctionCallError, t as ArgumentMismatchError } from "../evaluation-B6K0DbPS.mjs";
 export { ArgumentMismatchError, InvalidFunctionCallError };

package/dist/errors/evaluation.mjs

@@ -1,8 +1,8 @@
 import { LionExpressionSchema } from "../schemas/lion-expression.mjs";
 import { Schema } from "effect";
 //#region src/errors/evaluation.ts
-var ArgumentMismatchError = class extends Schema.TaggedError("ArgumentMismatchError")("ArgumentMismatchError", {}) {};
-var InvalidFunctionCallError = class extends Schema.TaggedError("InvalidFunctionCallError")("InvalidFunctionCallError", { expression: LionExpressionSchema }) {};
+var ArgumentMismatchError = class extends Schema.TaggedError()("ArgumentMismatchError", {}) {};
+var InvalidFunctionCallError = class extends Schema.TaggedError()("InvalidFunctionCallError", { expression: LionExpressionSchema }) {};
 //#endregion
 export { ArgumentMismatchError, InvalidFunctionCallError };
 

package/dist/errors/evaluation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"evaluation.mjs","names":[],"sources":["../../src/errors/evaluation.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport class ArgumentMismatchError extends Schema.TaggedError<ArgumentMismatchError>(\n  \"ArgumentMismatchError\"\n)(\"ArgumentMismatchError\", {}) {}\n\nexport class InvalidFunctionCallError extends Schema.TaggedError<InvalidFunctionCallError>(\n  \"InvalidFunctionCallError\"\n)(\"InvalidFunctionCallError\", { expression: LionExpressionSchema }) {}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,OAAO,YAChD,wBACD,CAAC,yBAAyB,EAAE,CAAC,CAAC;AAE/B,IAAa,2BAAb,cAA8C,OAAO,YACnD,2BACD,CAAC,4BAA4B,EAAE,YAAY,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"evaluation.mjs","names":[],"sources":["../../src/errors/evaluation.ts"],"sourcesContent":["import { Schema } from \"effect\";\nimport { LionExpressionSchema } from \"@/schemas/lion-expression\";\n\nexport class ArgumentMismatchError extends Schema.TaggedError<ArgumentMismatchError>()(\n  \"ArgumentMismatchError\",\n  {}\n) {}\n\nexport class InvalidFunctionCallError extends Schema.TaggedError<InvalidFunctionCallError>()(\n  \"InvalidFunctionCallError\",\n  { expression: LionExpressionSchema }\n) {}\n"],"mappings":";;;AAGA,IAAa,wBAAb,cAA2C,OAAO,aAAoC,CACpF,yBACA,EAAE,CACH,CAAC;AAEF,IAAa,2BAAb,cAA8C,OAAO,aAAuC,CAC1F,4BACA,EAAE,YAAY,sBAAsB,CACrC,CAAC"}