seam-lang 2.0.0

package/examples/vulnerability-impact.pl

@@ -0,0 +1,69 @@
+% Vulnerability impact analysis over a transitive dependency graph.
+% Services inherit exposure through direct and bounded transitive dependencies.
+% High-CVSS vulnerable packages derive risk and mitigation facts; critical
+% services additionally receive urgent patch recommendations.
+
+materialize(uses, 2).
+materialize(impacted_by, 2).
+materialize(risk, 2).
+materialize(mitigate, 2).
+materialize(urgent_patch, 2).
+
+service(webapp).
+service(worker).
+service(frontend).
+
+critical(webapp).
+critical(worker).
+
+depends_on(webapp, api).
+depends_on(worker, queue).
+depends_on(frontend, ui).
+depends_on(api, auth).
+depends_on(auth, openssl).
+depends_on(queue, openssl).
+depends_on(ui, css).
+
+vulnerability(openssl, cve_2026_0001).
+cvss(cve_2026_0001, 9.8).
+fixed_by(cve_2026_0001, openssl_3_0_14).
+
+vulnerability(css, cve_2026_0002).
+cvss(cve_2026_0002, 5.4).
+fixed_by(cve_2026_0002, css_2_1_1).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Dependency).
+
+uses(Service, Dependency) :-
+  service(Service),
+  depends_on(Service, Intermediate),
+  depends_on(Intermediate, Next),
+  depends_on(Next, Dependency).
+
+impacted_by(Service, Dependency) :-
+  uses(Service, Dependency).
+
+% exposed_to/2 connects dependency reachability to high-severity CVEs.
+exposed_to(Service, Vulnerability) :-
+  uses(Service, Package),
+  vulnerability(Package, Vulnerability),
+  cvss(Vulnerability, Score),
+  gt(Score, 7.0).
+
+risk(Service, high) :-
+  exposed_to(Service, _vulnerability).
+
+mitigate(Service, Vulnerability) :-
+  exposed_to(Service, Vulnerability).
+
+urgent_patch(Service, Patch) :-
+  critical(Service),
+  exposed_to(Service, Vulnerability),
+  fixed_by(Vulnerability, Patch).

package/examples/web-names.pl

@@ -0,0 +1,39 @@
+% Web names as first-class Seam atoms.
+%
+% Angle-bracket IRI atoms are ordinary atoms with globally meaningful names.
+% They are self-contained, require no prefix declarations, and can be joined
+% directly across rules just like any other atom.
+
+materialize(affiliated_with, 2).
+materialize(project_contact, 3).
+
+table(parent_organization, 2).
+
+% A tiny graph using absolute IRI atoms directly.
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/name>', "Jos De Roo").
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/email>', "josderoo@gmail.com").
+triple('<https://data.ugent.be/id/josd>', '<https://schema.org/affiliation>', '<https://data.ugent.be/id/idlab>').
+triple('<https://data.ugent.be/id/idlab>', '<https://schema.org/parentOrganization>', '<https://data.ugent.be/id/ugent>').
+
+triple('<https://github.com/eyereasoner/seam>', '<https://schema.org/name>', "seam").
+triple('<https://github.com/eyereasoner/seam>', '<https://schema.org/codeRepository>', '<https://github.com/eyereasoner/seam>').
+triple('<https://github.com/eyereasoner/seam>', '<https://schema.org/maintainer>', '<https://data.ugent.be/id/josd>').
+
+% Organization membership follows parentOrganization links transitively.
+parent_organization(Unit, Org) :-
+    triple(Unit, '<https://schema.org/parentOrganization>', Org).
+parent_organization(Unit, Org) :-
+    triple(Unit, '<https://schema.org/parentOrganization>', Mid),
+    parent_organization(Mid, Org).
+
+affiliated_with(Person, Org) :-
+    triple(Person, '<https://schema.org/affiliation>', Org).
+affiliated_with(Person, Org) :-
+    triple(Person, '<https://schema.org/affiliation>', Unit),
+    parent_organization(Unit, Org).
+
+% A project contact is derived by joining the project's maintainer with the
+% maintainer's email.  The join works because both facts use the same IRI atom.
+project_contact(Project, Person, Email) :-
+    triple(Project, '<https://schema.org/maintainer>', Person),
+    triple(Person, '<https://schema.org/email>', Email).

package/examples/weighted-interval-scheduling.pl

@@ -0,0 +1,81 @@
+% Weighted interval scheduling via tabled dynamic programming.
+%
+% Intervals are ordered by finish time.  best_from(I,Best) compares the two
+% choices at position I: skip it, or take it and jump to the next compatible
+% interval.  chosen_from/2 then walks the tabled decisions to report a schedule.
+materialize(weighted_interval_answer, 2).
+
+table(best_from, 2).
+
+last_interval(8).
+sentinel(9).
+
+interval(1, 1, 4, 5).
+interval(2, 3, 5, 1).
+interval(3, 0, 6, 8).
+interval(4, 4, 7, 4).
+interval(5, 3, 9, 6).
+interval(6, 5, 9, 3).
+interval(7, 6, 10, 2).
+interval(8, 8, 11, 4).
+
+% Find the earliest later interval whose start is not before I's finish.
+next_compatible(I, J) :-
+  interval(I, _start, Finish, _value),
+  aggregate_min(K, K,
+    (interval(K, Startk, _finishk, _valuek), gt(K, I), ge(Startk, Finish)),
+    J, J).
+next_compatible(I, 9) :-
+  interval(I, _start, Finish, _value),
+  not((interval(K, Startk, _finishk, _valuek), gt(K, I), ge(Startk, Finish))).
+
+best_from(9, 0).
+best_from(I, Best) :-
+  last_interval(Last),
+  le(I, Last),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  add(Value, Tail, Take),
+  max(Take, Skip, Best).
+
+% Reconstruction emits an interval when the take branch matches the optimal value.
+chosen_from(I, I) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  add(Value, Tail, Take),
+  eq(Best, Take),
+  ge(Take, Skip).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  add(Value, Tail, Take),
+  eq(Best, Take),
+  ge(Take, Skip),
+  chosen_from(Compatible, Chosen).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _start, _finish, Value),
+  add(Value, Tail, Take),
+  gt(Skip, Take),
+  chosen_from(Next, Chosen).
+
+weighted_interval_answer(best_value, Best) :- best_from(1, Best).
+weighted_interval_answer(chosen_interval, interval(I, Start, Finish, Value)) :-
+  chosen_from(1, I),
+  interval(I, Start, Finish, Value).
+weighted_interval_answer(candidate_count, Count) :- countall(interval(_i, _start, _finish, _value), Count).

package/examples/witch.pl

@@ -0,0 +1,38 @@
+% Burn the witch, adapted from Eyeling's examples/witch.n3.
+%
+% This is the classic N3/Semantic Web rule chain in seam form: a duck
+% floats; something with the same weight as something that floats also floats;
+% things that float are made of wood; things made of wood burn; and a woman
+% who burns is a witch.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(floats, 1).
+materialize(madeOfWood, 1).
+materialize(burns, 1).
+materialize(witch, 1).
+materialize(is, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+witch(X) :-
+  burns(X),
+  woman(X).
+
+woman(girl).
+
+burns(X) :-
+  madeOfWood(X).
+
+madeOfWood(X) :-
+  floats(X).
+
+floats(duck).
+
+floats(Y) :-
+  sameWeight(X, Y),
+  floats(X).
+
+sameWeight(duck, girl).
+
+is(witchExample, true) :-
+  witch(girl).

package/examples/wolf-goat-cabbage.pl

@@ -0,0 +1,56 @@
+% Wolf, goat and cabbage puzzle, adapted from Eyelet's
+% input/wolf-goat-cabbage.pl.
+%
+% A configuration is [man, wolf, goat, cabbage], where each item is on the west
+% bank w or east bank e.  The recursive search keeps a visited list so seam
+% explores the finite state space without looping.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(solution, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+table(solve, 4).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+solution(Moves) :-
+  solve([w, w, w, w], [e, e, e, e], [[w, w, w, w]], Moves),
+  length(Moves, 7).
+
+solve(Config, Config, _visited, []).
+
+solve(Config, Goal, Visited, [Move|Rest]) :-
+  move(Config, Move, Nextconfig),
+  safe(Nextconfig),
+  not_member(Nextconfig, Visited),
+  solve(Nextconfig, Goal, [Nextconfig|Visited], Rest).
+
+% Each move transforms one configuration into another.
+move([X, X, Goat, Cabbage], wolf, [Y, Y, Goat, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, X, Cabbage], goat, [Y, Wolf, Y, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, X], cabbage, [Y, Wolf, Goat, Y]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, Cabbage], nothing, [Y, Wolf, Goat, Cabbage]) :-
+  change(X, Y).
+
+change(e, w).
+change(w, e).
+
+% Safe if the goat is not left alone with the wolf or cabbage without the man.
+safe([Man, Wolf, Goat, Cabbage]) :-
+  one_eq(Man, Goat, Wolf),
+  one_eq(Man, Goat, Cabbage).
+
+one_eq(X, X, _).
+one_eq(X, _, X).
+
+solution(puzzle, Moves) :-
+  solution(Moves).
+
+solved(puzzle, true) :-
+  solution(_moves).

package/examples/workplace-compliance.pl

@@ -0,0 +1,41 @@
+% Workplace compliance from explicit action facts.
+%
+% The source example generated a large dynamic dataset.  Seam keeps the data
+% explicit and reproducible: each `does/2` fact records an observed employee
+% action, and the rules classify compliant and non-compliant behaviour.
+
+materialize(status, 2).
+
+employee(alice).
+employee(bob).
+employee(carol).
+employee(dave).
+
+does(alice, log_off_at_end_of_shift).
+does(bob, work_related_task).
+does(bob, log_off_at_end_of_shift).
+does(carol, access_social_media).
+does(dave, work_related_task).
+
+% Work-related activity is compliant when the employee also logs off.
+status(Person, compliant) :-
+  employee(Person),
+  does(Person, work_related_task),
+  does(Person, log_off_at_end_of_shift).
+
+% Logging off is compliant by itself when no work task was observed.
+status(Person, compliant) :-
+  employee(Person),
+  does(Person, log_off_at_end_of_shift),
+  not(does(Person, work_related_task)).
+
+% A work task without the required log-off is non-compliant.
+status(Person, non_compliant) :-
+  employee(Person),
+  does(Person, work_related_task),
+  not(does(Person, log_off_at_end_of_shift)).
+
+% Accessing social media is non-compliant in this policy.
+status(Person, non_compliant) :-
+  employee(Person),
+  does(Person, access_social_media).

package/examples/zebra.pl

@@ -0,0 +1,45 @@
+% Zebra puzzle, adapted from Eyelet's input/zebra.pl.
+%
+% Five houses are represented as house(Color, Nationality, Pet, Beverage,
+% Cigarette).  Each clue is a member/2, first/2, third/2, next_to/3, or adjacent/3
+% constraint over that list.  The answer is the classic one: the Norwegian drinks
+% water and the Japanese owns the zebra.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(waterDrinker, 2).
+materialize(zebraOwner, 2).
+materialize(solved, 2).
+
+% The single zebra/2 rule is a finite constraint model over the five house slots.
+zebra(Waterdrinker, Zebraowner) :-
+  eq(Houses, [_, _, _, _, _]),
+  first(Houses, house(_, norwegian, _, _, _)),
+  third(Houses, house(_, _, _, milk, _)),
+  adjacent(house(_, norwegian, _, _, _), house(blue, _, _, _, _), Houses),
+  next_to(house(ivory, _, _, _, _), house(green, _, _, _, _), Houses),
+  member(house(red, english, _, _, _), Houses),
+  member(house(green, _, _, coffee, _), Houses),
+  member(house(yellow, _, _, _, kools), Houses),
+  member(house(_, spanish, dog, _, _), Houses),
+  member(house(_, ukrainian, _, tea, _), Houses),
+  member(house(_, _, snail, _, old_gold), Houses),
+  adjacent(house(_, _, _, _, chesterfields), house(_, _, fox, _, _), Houses),
+  adjacent(house(_, _, _, _, kools), house(_, _, horse, _, _), Houses),
+  member(house(_, _, _, orange_juice, lucky_strike), Houses),
+  member(house(_, japanese, _, _, parliaments), Houses),
+  member(house(_, Waterdrinker, _, water, _), Houses),
+  member(house(_, Zebraowner, zebra, _, _), Houses).
+
+% Positional and neighborhood helpers keep the clue encoding readable.
+first([X|_], X).
+third([_, _, X|_], X).
+
+adjacent(A, B, List) :- next_to(A, B, List).
+adjacent(A, B, List) :- next_to(B, A, List).
+
+next_to(X, Y, [X, Y|_]).
+next_to(X, Y, [_|Zs]) :- next_to(X, Y, Zs).
+
+waterDrinker(zebraPuzzle, Waterdrinker) :- zebra(Waterdrinker, _zebraowner).
+zebraOwner(zebraPuzzle, Zebraowner) :- zebra(_waterdrinker, Zebraowner).
+solved(zebraPuzzle, true) :- zebra(norwegian, japanese).

package/index.d.ts

@@ -0,0 +1,230 @@
+export interface SeamStats {
+  [key: string]: number;
+}
+
+export interface SeamRunOptions {
+  proof?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  maxDepth?: number;
+  solutionLimit?: number;
+  registry?: BuiltinRegistry;
+  sourceMetadata?: boolean;
+  markRecursive?: boolean;
+  strictNegation?: boolean;
+  analyzeNegation?: boolean;
+  [key: string]: unknown;
+}
+
+export interface SeamRunResult {
+  stdout: string;
+  stats: SeamStats;
+}
+
+export interface SeamSourcePart {
+  text?: string;
+  source?: string;
+  filename?: string;
+}
+
+export interface SeamClause {
+  head: SeamTerm;
+  body: SeamTerm[];
+  index?: number;
+  filename?: string;
+  clauseNumber?: number;
+}
+
+export interface SeamPredicateGroup {
+  name: string;
+  arity: number;
+  clauses: SeamClause[];
+  argIndexes: unknown[];
+  pairIndexes: unknown[];
+  tabled: boolean;
+  mode: string[] | null;
+  determinism: 'det' | 'semidet' | null;
+  recursive: boolean;
+  negationStratum: number | null;
+}
+
+export type SeamTerm = Term | { type: string; name: string; args?: SeamTerm[]; arity?: number };
+
+export class Term {
+  constructor(type: string, name?: unknown, args?: SeamTerm[]);
+  type: string;
+  name: string;
+  args: SeamTerm[];
+  get arity(): number;
+}
+
+export class Env {
+  constructor(bindings?: Iterable<readonly [string, SeamTerm]> | null);
+  bindings: Map<string, SeamTerm>;
+  clone(): Env;
+  has(name: string): boolean;
+  get(name: string): SeamTerm | undefined;
+  bind(name: string, term: SeamTerm): void;
+}
+
+export class Program {
+  constructor(clauses?: SeamClause[], options?: SeamRunOptions);
+  clauses: SeamClause[];
+  groups: Map<string, SeamPredicateGroup>;
+  materializedGroups: Set<string>;
+  hasMaterialize: boolean;
+  negationDependencies: Array<{ from: string; to: string; negative: boolean }>;
+  negationStratificationErrors: Array<{ from: string; to: string }>;
+  stratifiedNegation: boolean;
+  static parse(source: string, options?: SeamRunOptions): Program;
+  static parseSources(sources?: Array<string | SeamSourcePart>, options?: SeamRunOptions): Program;
+  makeGroup(name: string, arity: number): SeamPredicateGroup;
+  indexClause(clause: SeamClause): void;
+  findGroup(name: string, arity: number): SeamPredicateGroup | null;
+  applyDeclarations(options?: SeamRunOptions): void;
+  markRecursivePredicates(): void;
+  analyzeNegationStratification(): Array<{ from: string; to: string }>;
+  assertStratifiedNegation(): true;
+  isStratifiedNegation(): boolean;
+  hasMaterializeDeclarations(): boolean;
+  groupIsMaterialized(group: SeamPredicateGroup): boolean;
+  groupHasRule(group: SeamPredicateGroup): boolean;
+  sourceFactLines(predicateKeys?: Set<string> | null): Set<string>;
+  materializationGoals(): SeamTerm[];
+}
+
+export interface BuiltinDefinition {
+  name: string;
+  arity: number;
+  handler: BuiltinHandler;
+  deterministic: boolean;
+  ready: ((solver: Solver, goal: SeamTerm, env: Env) => boolean) | null;
+  fallbackWhenNotReady: boolean;
+  shouldUse: ((solver: Solver, goal: SeamTerm, env: Env) => boolean) | null;
+}
+
+export type BuiltinHandler = (context: { solver: Solver; goal: SeamTerm; env: Env }) => Iterable<Env>;
+
+export class BuiltinRegistry {
+  constructor();
+  defs: Map<string, BuiltinDefinition>;
+  add(name: string, arity: number, handler: BuiltinHandler, options?: Partial<BuiltinDefinition>): this;
+  get(name: string, arity: number): BuiltinDefinition | null;
+}
+
+export class Solver {
+  constructor(program: Program, options?: SeamRunOptions);
+  program: Program;
+  registry: BuiltinRegistry;
+  maxDepth: number;
+  solutionLimit: number;
+  solutionsSeen: number;
+  active: unknown[];
+  memo: Map<string, unknown>;
+  stats: SeamStats;
+  cloneForInnerGoal(solutionLimit?: number): Solver;
+  solve(goals: SeamTerm | SeamTerm[], env?: Env, depth?: number): Iterable<Env>;
+  activeVariant(goal: SeamTerm, env: Env): boolean;
+}
+
+export const VAR: 'var';
+export const ATOM: 'atom';
+export const STRING: 'string';
+export const NUMBER: 'number';
+export const COMPOUND: 'compound';
+
+export function variable(name: string): Term;
+export function atom(name: string): Term;
+export function stringTerm(value: string): Term;
+export function numberTerm(value: string | number): Term;
+/** Construct a compound term; an empty argument list is canonicalized to atom(name). */
+export function compound(name: string, args?: SeamTerm[]): Term;
+export function emptyList(): Term;
+export function cons(head: SeamTerm, tail: SeamTerm): Term;
+export function deref(term: SeamTerm, env: Env): SeamTerm;
+export function isScalar(term: SeamTerm | null | undefined): boolean;
+export function isEmptyList(term: SeamTerm | null | undefined): boolean;
+export function isCons(term: SeamTerm | null | undefined): boolean;
+export function isConjunction(term: SeamTerm | null | undefined): boolean;
+export function unify(left: SeamTerm, right: SeamTerm, env: Env): boolean;
+export function cloneTerm(term: SeamTerm): Term;
+export function freshTerm(term: SeamTerm, suffix: string | number): Term;
+export function copyResolved(term: SeamTerm, env: Env): Term;
+export function termIsGround(term: SeamTerm, env?: Env): boolean;
+export function termToString(term: SeamTerm, env?: Env, quoteStrings?: boolean): string;
+export function lexicalValue(term: SeamTerm, env: Env): string | null;
+export function properListItems(list: SeamTerm, env: Env): SeamTerm[] | null;
+export function listFromItems(items: SeamTerm[], start?: number, end?: number, tail?: SeamTerm): Term;
+export function flattenConjunction(goal: SeamTerm): SeamTerm[];
+export function termSignature(term: SeamTerm | null | undefined): string | null;
+export function variantTerms(left: SeamTerm, leftEnv: Env, right: SeamTerm, rightEnv: Env, pairs?: Map<string, string>, reverse?: Map<string, string>): boolean;
+export function compareTerms(left: SeamTerm, right: SeamTerm): number;
+export function isDecimalInteger(text: string | null | undefined): boolean;
+export function compareIntegerText(left: string, right: string): number;
+export function parseFiniteNumber(text: string | null | undefined): number | null;
+export function numberTextFromDouble(value: number): string | null;
+export function compareNumberText(left: string, right: string): number;
+
+export function makeProgram(source: string, options?: SeamRunOptions): Program;
+export function parseClauses(source: string, options?: SeamRunOptions): SeamClause[];
+export function parseProgramText(source: string, options?: SeamRunOptions): SeamClause[];
+export function createDefaultRegistry(): BuiltinRegistry;
+export function getDefaultRegistry(): BuiltinRegistry;
+export function run(source: string | Program, options?: SeamRunOptions): SeamRunResult;
+export function whyProof(program: Program, goal: SeamTerm, options?: SeamRunOptions): { ok: boolean; text: string };
+export function whyNoProof(goal: SeamTerm): string;
+export function explainProof(program: Program, goal: SeamTerm, options?: SeamRunOptions): { ok: boolean; text: string };
+
+declare const seam: {
+  VAR: typeof VAR;
+  ATOM: typeof ATOM;
+  STRING: typeof STRING;
+  NUMBER: typeof NUMBER;
+  COMPOUND: typeof COMPOUND;
+  Term: typeof Term;
+  Env: typeof Env;
+  Program: typeof Program;
+  Solver: typeof Solver;
+  BuiltinRegistry: typeof BuiltinRegistry;
+  variable: typeof variable;
+  atom: typeof atom;
+  stringTerm: typeof stringTerm;
+  numberTerm: typeof numberTerm;
+  compound: typeof compound;
+  emptyList: typeof emptyList;
+  cons: typeof cons;
+  deref: typeof deref;
+  isScalar: typeof isScalar;
+  isEmptyList: typeof isEmptyList;
+  isCons: typeof isCons;
+  isConjunction: typeof isConjunction;
+  unify: typeof unify;
+  cloneTerm: typeof cloneTerm;
+  freshTerm: typeof freshTerm;
+  copyResolved: typeof copyResolved;
+  termIsGround: typeof termIsGround;
+  termToString: typeof termToString;
+  lexicalValue: typeof lexicalValue;
+  properListItems: typeof properListItems;
+  listFromItems: typeof listFromItems;
+  flattenConjunction: typeof flattenConjunction;
+  termSignature: typeof termSignature;
+  variantTerms: typeof variantTerms;
+  compareTerms: typeof compareTerms;
+  isDecimalInteger: typeof isDecimalInteger;
+  compareIntegerText: typeof compareIntegerText;
+  parseFiniteNumber: typeof parseFiniteNumber;
+  numberTextFromDouble: typeof numberTextFromDouble;
+  compareNumberText: typeof compareNumberText;
+  makeProgram: typeof makeProgram;
+  parseClauses: typeof parseClauses;
+  parseProgramText: typeof parseProgramText;
+  createDefaultRegistry: typeof createDefaultRegistry;
+  getDefaultRegistry: typeof getDefaultRegistry;
+  run: typeof run;
+  whyProof: typeof whyProof;
+  whyNoProof: typeof whyNoProof;
+  explainProof: typeof explainProof;
+};
+
+export default seam;

package/index.js

@@ -0,0 +1,4 @@
+// Public Seam JavaScript API.
+export * from './src/index.js';
+import * as seam from './src/index.js';
+export default seam;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "seam-lang",
+  "version": "2.0.0",
+  "description": "A small Prolog-like logic programming language for facts, rules, goals, answers, and proofs.",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "bin": {
+    "seam": "./bin/seam.js"
+  },
+  "keywords": [
+    "logic",
+    "rules",
+    "prolog",
+    "reasoner",
+    "proofs"
+  ],
+  "license": "MIT",
+  "author": "Jos De Roo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eyereasoner/seam.git"
+  },
+  "homepage": "https://github.com/eyereasoner/seam#readme",
+  "files": [
+    "LICENSE.md",
+    "README.md",
+    "index.js",
+    "index.d.ts",
+    "playground.html",
+    "bin",
+    "src",
+    "conformance-report.md",
+    "docs",
+    "examples",
+    "test"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node test/run-all.mjs",
+    "test:seam": "node test/run-all.mjs",
+    "test:conformance": "node test/run-conformance.mjs",
+    "test:examples": "node test/run-examples.mjs",
+    "test:regression": "node test/run-regression.mjs",
+    "preversion": "npm test && npm run conformance:report -- conformance-report.md",
+    "postversion": "git push origin HEAD --follow-tags",
+    "conformance:report": "node test/run-conformance-report.mjs"
+  }
+}