@bjornpagen/bumbledb 0.20.2 → 1.0.0

package/src/index.ts

@@ -1,20 +1,9 @@
 /**
- * @bjornpagen/bumbledb — the type-theoretic TypeScript SDK for the
- * bumbledb embedded relational engine. Public surface: the structural type
- * kernel (fields as pure structure, `relation`, `closed` — domains are
- * never declared: THE LAWS TYPE THE COLUMNS, `schema` computing every
- * field's equivalence class FROM the statement list at both tiers), the
- * statement algebra with `schema` and `SchemaSpec` lowering (PRD-06), the `Db`
- * runtime (exclusive-lock stores, transactions, typed violations, callback
- * instance reads, one-shot `write`/`writeFrom` with `abandon` — PRD-07), the query surface (kysely-shaped:
- * `query(S).rule(r => { const { id, name } = v(Holder); return r.match(Holder, { id, name }).find({ name }) })` —
- * variables minted by `v` and joined by OBJECT REFERENCE (reuse is the
- * join), the head a `find` RECORD whose keys name the answer columns
- * (renames are real), params still STRING-named, plus negation,
- * conditions, aggregates, and interiors / one linear rec via
- * `q.interior` / `q.reach` —
- * `db.prepare` as a plain value; comparisons and connectives live on
- * the rule scope). The raw native bridge is not exported.
+ * @bjornpagen/bumbledb — the Effect-native TypeScript SDK for the
+ * bumbledb embedded relational engine (chapter 35 surface). Pure
+ * schema/query/scalar construction is synchronous metadata; all work is
+ * lazy, scoped and bounded on the one native runtime. No Promise, sync,
+ * or disposal twin. The raw native bridge is not exported from this barrel.
  */
 
 export type {
@@ -23,10 +12,12 @@ export type {
 	CapacityWindow,
 	DurationRef,
 	FieldRef,
-	UnitWindowBan,
+	UnitDimensionBan,
 	WeightOnSource
 } from "#capacity.ts"
 export { duration, ref, weigh, within } from "#capacity.ts"
+export type { ChangeDraft } from "#changes.ts"
+export { ChangeSet } from "#changes.ts"
 export type {
 	AnyClosed,
 	AnySelectedClosed,
@@ -42,47 +33,28 @@ export type {
 	SelectedClosed
 } from "#closed.ts"
 export { closed } from "#closed.ts"
+export type { RowShape } from "#codec.ts"
+export { decodeBoundaryRows, decodeRows, encodeBoundaryRows, encodeRows, rowSchema, rowShape } from "#codec.ts"
+export type { CompiledSchema, SchemaId } from "#compile.ts"
+export { Schema } from "#compile.ts"
 export type {
-	Abandon,
-	AbandonedArm,
-	Admission,
-	CapacityViolation,
-	CollectionWrite,
-	Committed,
-	ContainmentViolation,
-	DeclaredKeyFact,
-	DeclaredKeyViolation,
-	DeltaBuild,
-	FreshRange,
-	ImpliedKeyViolation,
-	MemberRelation,
-	MirrorViolation,
-	MutationReport,
-	OffendingFact,
-	OwnedInstance,
-	Prepared,
-	ReadInstance,
-	SyncResult,
-	Violation,
-	Witness,
-	WriteFromOutcome,
-	WriteOutcome,
-	WriteTx
+	ApplyExpected,
+	ApplyOptions,
+	ApplyOutcome,
+	CoreWitness,
+	DbInspection,
+	ExecutionSession,
+	QueryReader,
+	Snapshot
 } from "#db.ts"
+export { Db } from "#db.ts"
 export {
-	abandon,
-	Db,
-	ErrAsyncCallback,
-	ErrFingerprintMismatch,
-	ErrForeignPrepared,
-	ErrForeignWitness,
-	ErrIrError,
-	ErrNewtypeMismatch,
-	ErrSchemaError,
-	ErrSpentHandle,
-	ErrUseAfterScope,
-	InstanceBuilder
-} from "#db.ts"
+	AuthoringError,
+	NativeLoadError,
+	NativeOperationError,
+	NativeReportedError,
+	SdkInvariantError
+} from "#errors.ts"
 export type {
 	AnyFace,
 	Arity,
@@ -109,83 +81,27 @@ export type {
 	ClosedHandleTuple,
 	ClosedIdField,
 	ClosedRoster,
-	FreshU64Field,
+	F64Field,
+	FloatIntervalValue,
 	I64Field,
 	Infer,
+	IntervalElementKind,
 	IntervalField,
 	IntervalValue,
 	SignatureOf,
 	StrField,
-	U64Field
+	U64Field,
+	UuidField
 } from "#fields.ts"
-export { bool, bytes, i64, interval, span, str, u64 } from "#fields.ts"
+export { bool, bytes, f64, i64, interval, span, str, u64, uuid } from "#fields.ts"
 export type { Same, SameLen } from "#judgment.ts"
 export type { ClassesOf, ClassWall, LawfulStatements, RelationClasses, SchemaClasses } from "#law.ts"
-export { lower } from "#lower.ts"
-export type { KeyFact } from "#marshal.ts"
-export { factOf, rowOf } from "#marshal.ts"
-export type {
-	FactValue,
-	LogBatch,
-	LogBatchDecodeKind,
-	LogBatchEncodeKind,
-	LogBatchHeader,
-	LogBraidComponent,
-	LogBraids,
-	LogChain,
-	LogChainEntry,
-	LogCheckpointDoc,
-	LogCheckpointHead,
-	LogCheckpointKind,
-	LogCodecHandle,
-	LogManifestDoc,
-	LogManifestKind,
-	LogOpIn,
-	LogOpKind,
-	LogOpOut,
-	LogPendingBatch,
-	LogResult,
-	LogSidecarKind,
-	ParsedQuery,
-	QueryIr,
-	SealedDescriptor,
-	SealedHi,
-	SealedSide,
-	SealedStatement,
-	SealedWeight,
-	StatementKindTag
-} from "#native.ts"
-export {
-	internalBlake3,
-	internalDescriptor,
-	internalLogBraidsOf,
-	internalLogCodec,
-	internalLogDecodeBatch,
-	internalLogEncodeBatch,
-	internalLogParseCheckpoint,
-	internalLogParseCkptScratch,
-	internalLogParseManifest,
-	internalLogParseSidecar,
-	internalLogRenderCheckpoint,
-	internalLogRenderCkptScratch,
-	internalLogRenderManifest,
-	internalLogRenderSidecar
-} from "#native.ts"
-
-export type {
-	AnyCond,
-	BindingInput,
-	Cmp,
-	FindColumn,
-	InteriorData,
-	MatchShape,
-	NotAtom,
-	RecData,
-	RuleData,
-	Tree
-} from "#query/atom.ts"
+export type { Violation, ViolationFact } from "#native.ts"
+export type { FindColumn } from "#query/atom.ts"
 export { ALLEN } from "#query/atom.ts"
-export type { Agg, FindEntry } from "#query/find.ts"
+export type { AnyComputeExpr, ComputeExpr, ComputeValue, QueryNode } from "#query/compute.ts"
+export { Compute } from "#query/compute.ts"
+export type { Agg, RowOfFind } from "#query/find.ts"
 export type {
 	AnyQuery,
 	AnyRuleValue,
@@ -206,6 +122,7 @@ export type {
 export { lowerQuery, query } from "#query/lower.ts"
 export type {
 	ClassedField,
+	Flatten,
 	MatchFields,
 	MatchOwner,
 	Param,
@@ -221,7 +138,6 @@ export type {
 	AnySelected,
 	Fact,
 	FieldsShape,
-	FreshKeys,
 	Relation,
 	RelationData,
 	RelationField,
@@ -231,8 +147,28 @@ export type {
 	SelectionInput
 } from "#relation.ts"
 export { relation } from "#relation.ts"
-export type { AnySchema, Schema, SchemaRelation, SchemaRelations } from "#schema.ts"
+export type { CompleteResult } from "#result.ts"
+export type { CellValue } from "#rows.ts"
+export { cellBytes, cellOf, factOfCells, flatRowsOf, keyCellsOf } from "#rows.ts"
+export type { ExecutionPolicy, NativeRuntimeOptions } from "#runtime.ts"
+export { NativeRuntime } from "#runtime.ts"
+export type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
+export { CloseFailure, DbError, dbError, runtimeErrorCodes } from "#runtime-errors.ts"
+export type {
+	NumericCast,
+	ScalarExpr,
+	ScalarFieldRef,
+	ScalarKind,
+	ScalarLeafScope,
+	ScalarLiteral,
+	ScalarNode,
+	ScalarResultKind,
+	ScalarValue
+} from "#scalar.ts"
+export { Scalar } from "#scalar.ts"
+export type { AnySchema, Schema as SchemaDeclaration, SchemaRelation, SchemaRelations } from "#schema.ts"
 export { schema } from "#schema.ts"
+export type { Key, QueryTemplate, Rel } from "#shape.ts"
 export type {
 	CapacityBoundSpec,
 	CapacityWindowSpec,
@@ -245,8 +181,7 @@ export type {
 	SideSpec,
 	StatementSpec,
 	ValueSpec,
-	ValueTypeSpec,
-	WeightSpec
+	ValueTypeSpec
 } from "#spec.ts"
 export type {
 	CapacityData,
@@ -259,3 +194,4 @@ export type {
 	StatementData
 } from "#statements.ts"
 export { capacity, contained, key, mirrors, renderStatement } from "#statements.ts"
+export { Uuid } from "#uuid.ts"

package/src/internal/log.ts

@@ -0,0 +1,51 @@
+/**
+ * @bjornpagen/bumbledb/internal/log — the exact-version cross-package seam
+ * consumed by `@bjornpagen/bumbledb-log`. Unsupported application surface;
+ * not a security boundary. Native kind/runtime/owner/state validation remains
+ * mandatory on every verb. Real types are shipped; this is not stripInternal.
+ */
+export type { ChangeDraft } from "#changes.ts"
+export { ChangeSet, internalChanges } from "#changes.ts"
+export type { CompiledSchema, SchemaId } from "#compile.ts"
+export { Schema } from "#compile.ts"
+export type { ExecutionSession, QueryReader } from "#db.ts"
+export { Db, internalPublishedReader } from "#db.ts"
+export type { SnapshotHandle } from "#db-native.ts"
+export { lower } from "#lower.ts"
+export { internalMigrationRead, internalMigrationSchema } from "#migration.ts"
+export {
+	internalBlake3,
+	internalDescriptor,
+	internalLogIdentities,
+	internalLogSchema,
+	nativeBindingIsLoaded
+} from "#native.ts"
+export type { CompleteResult } from "#result.ts"
+export type { ExecutionPolicy, NativeRuntimeOptions, RepositoryLock } from "#runtime.ts"
+export {
+	deliveryResultBytes,
+	finalizeClose,
+	hashChunk,
+	internalAcquireRepositoryLock,
+	NativeRuntime,
+	nativeOperation,
+	nativeOperationWith,
+	policyWire,
+	runtimeHandle
+} from "#runtime.ts"
+export type { CloseReport, OutstandingWork } from "#runtime-errors.ts"
+export { CloseFailure, DbError, dbError, runtimeErrorCodes } from "#runtime-errors.ts"
+export type {
+	Capability,
+	CloseDrain,
+	CloseWire,
+	DirectoryHandle,
+	InspectionWire,
+	NativeKind,
+	OperationHandle,
+	PolicyWire,
+	RepositoryLockHandle,
+	ResourceHeader,
+	RuntimeHandle
+} from "#runtime-native.ts"
+export { runtimeNative } from "#runtime-native.ts"

package/src/law.ts

@@ -1,3 +1,4 @@
+import { AuthoringError } from "#errors.ts"
 /**
  * The law-typing engine (owner ruling 2026-07-18, "option 2, zero debate"):
  * THE LAWS TYPE THE COLUMNS. Domains are declared nowhere — `schema`
@@ -8,9 +9,10 @@
  *
  * The three class laws (ratified; implemented exactly):
  *
- * 1. GENERATORS — a `fresh` field is a generator and names its class by
- * its declaration coordinate (`"Account.id"`); a closed relation's
- * synthetic id is a generator named `"Kind.id"`.
+ * 1. GENERATORS — a closed relation's synthetic id is a generator named
+ * `"Kind.id"` (the vocabulary mints its own row ids). Ordinary relations
+ * have no generator: the database issues no identity (`fresh` is deleted),
+ * and identity fields are ordinary application-owned values.
  * 2. GENERATOR-LESS classes are named by their least member coordinate
  * in relation-declaration × field-declaration order (readable off the
  * relation record and each member's frozen field list at the VALUE
@@ -54,7 +56,6 @@
  * silently widened.
  */
 
-import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember, sealedFieldsOf } from "#closed.ts"
 import type { FaceData } from "#face.ts"
@@ -81,15 +82,7 @@ type MemberFieldNames<M extends SchemaRelation> = M extends AnyClosed
 		? keyof RelationFields<M> & string
 		: never
 
-type FreshFieldNames<Fields> = {
-	[F in keyof Fields & string]: Fields[F] extends { readonly fresh: true } ? F : never
-}[keyof Fields & string]
-
-type MemberGenerators<N extends string, M extends SchemaRelation> = M extends AnyClosed
-	? `${N}.id`
-	: M extends AnyRelation
-		? `${N}.${FreshFieldNames<RelationFields<M>>}`
-		: never
+type MemberGenerators<N extends string, M extends SchemaRelation> = M extends AnyClosed ? `${N}.id` : never
 
 type GeneratorsOf<Rels extends SchemaRelations> = {
 	[N in keyof Rels & string]: MemberGenerators<N, Rels[N]>
@@ -204,7 +197,7 @@ type KeyEntry = readonly [string, string]
 /**
  * Every declared `key` of a statements tuple as {@link KeyEntry} rows —
  * the declared half of the target-key roster (the implied half is read off
- * each target face's own relation value: fresh marks, closed ids). A
+ * each target face's own relation value: closed ids). A
  * statement-tuple union or any undecidable key element degrades the WHOLE
  * wall to silent before this roster is ever consulted
  * ({@link DecidableRoster}) — the skip arm here is the same judgment
@@ -329,12 +322,6 @@ type DeclaredKeyMatch<N extends string, PU extends string, Keys extends readonly
 		: DeclaredKeyMatch<N, PU, T>
 	: TargetKeyWall<N, PU>
 
-type FreshKeyMatch<PU extends string, O extends AnyRelation> = [PU] extends [FreshFieldNames<RelationFields<O>>]
-	? true extends IsMulti<PU>
-		? false
-		: true
-	: false
-
 type JudgeTargetFace<F extends FaceData, Keys extends readonly KeyEntry[]> = string extends F["owner"]["name"]
 	? true
 	: string extends F["projection"][number]
@@ -344,9 +331,7 @@ type JudgeTargetFace<F extends FaceData, Keys extends readonly KeyEntry[]> = str
 				? true
 				: TargetKeyWall<F["owner"]["name"], F["projection"][number]>
 			: F["owner"] extends AnyRelation
-				? FreshKeyMatch<F["projection"][number], F["owner"]> extends true
-					? true
-					: DeclaredKeyMatch<F["owner"]["name"], F["projection"][number], Keys>
+				? DeclaredKeyMatch<F["owner"]["name"], F["projection"][number], Keys>
 				: true
 
 type JudgeStatement<St extends Statement, Keys extends readonly KeyEntry[]> = St["data"] extends {
@@ -410,7 +395,7 @@ function memberCoords(relations: SchemaRelations): MemberCoords[] {
 		const fields = sealedFieldsOf(member).map(function fieldCoord(declared) {
 			return {
 				name: declared.name,
-				generator: closed ? declared.name === "id" : "fresh" in declared.field && declared.field.fresh === true
+				generator: closed && declared.name === "id"
 			}
 		})
 		out.push({ relation: relationName, fields })
@@ -478,7 +463,7 @@ function statementFaces(statement: Statement): readonly [FaceData, FaceData] | u
 /**
  * Computes the class map — the runtime twin of {@link ClassesOf}, the SAME
  * computation as a plain union-find: every paired face's positionwise slot
- * pairs union their coordinates; a fresh field or closed id is a generator
+ * pairs union their coordinates; a closed id is a generator
  * naming its class; a generator-less class is named by its least member in
  * relation-declaration × field-declaration order; a slot in no law is bare
  * (`undefined`). The one-generator wall throws HERE, naming the two
@@ -520,9 +505,9 @@ function computeClasses(name: string, relations: SchemaRelations, statements: re
 			const root = uf.union(coordA, coordB)
 			const gens = uf.generatorsOf(root)
 			if (gens.length > 1) {
-				throw errors.new(
-					`schema ${name}: the statements unify two generators into one class — ${gens.join(" and ")} (two mints cannot share a carrier) — ${renderStatement(statement)}`
-				)
+				throw new AuthoringError({
+					message: `schema ${name}: the statements unify two generators into one class — ${gens.join(" and ")} (two mints cannot share a carrier) — ${renderStatement(statement)}`
+				})
 			}
 		})
 	}

package/src/lower.ts

@@ -1,3 +1,4 @@
+import { AuthoringError } from "#errors.ts"
 /**
  * Descriptor lowering: SDK values down to the PRD-01 `SchemaSpec` plain
  * data (`#spec.ts`), which the napi bridge marshals verbatim. Lowering is
@@ -12,7 +13,6 @@
  * so serialization is deterministic (byte-stable).
  */
 
-import * as errors from "@superbuilders/errors"
 import type { AnyClosed } from "#closed.ts"
 import { isClosedMember } from "#closed.ts"
 import type { FaceData } from "#face.ts"
@@ -39,6 +39,10 @@ function valueTypeOf(field: AnyField): ValueTypeSpec {
 			return { kind: "u64" }
 		case "i64":
 			return { kind: "i64" }
+		case "f64":
+			return { kind: "f64" }
+		case "uuid":
+			return { kind: "uuid" }
 		case "str":
 			return { kind: "string" }
 		case "bytes":
@@ -52,8 +56,7 @@ function lowerField(name: string, field: AnyField, newtype: string | undefined):
 	return {
 		name,
 		valueType: valueTypeOf(field),
-		newtype,
-		fresh: "fresh" in field && field.fresh === true
+		newtype
 	}
 }
 
@@ -113,7 +116,9 @@ function lowerClosed(member: AnyClosed, classes: RelationClasses): RelationSpec
 	})
 	const newtype = classes.id
 	if (newtype === undefined) {
-		throw errors.new(`closed relation ${member.name}: the id's generator class is missing from the class map`)
+		throw new AuthoringError({
+			message: `closed relation ${member.name}: the id's generator class is missing from the class map`
+		})
 	}
 	return { name: member.name, fields, closed: { newtype, rows } }
 }

package/src/migration.ts

@@ -0,0 +1,69 @@
+/**
+ * Private log-migration integration entrypoints (C11): the two read-only
+ * native migration-codec verbs the `@bjornpagen/bumbledb-log/migrations`
+ * generator consumes literally (recorded contract in
+ * implementation/packets/P10.md), wired over the P06 executor onto P09's
+ * native `schema_file`/`migration::plan`/`migration::manifest` lanes.
+ *
+ * Both follow `hashChunk`'s shape: bounded owned input, bounded owned JSON
+ * response bytes, ONE registered cancellable operation under the acquired
+ * `NativeRuntime`. The schema verb takes the SDK `SchemaSpec` object — the
+ * same wire that already crosses the bridge for open/create — never a
+ * respelled text form. Neither verb opens, initializes, freezes or migrates
+ * a database; the durable migrate/activate/abort workflow is the log's
+ * admin surface, not this seam.
+ */
+import { Effect } from "effect"
+import { dbNative } from "#db-native.ts"
+import type { ExecutionPolicy } from "#runtime.ts"
+import { nativeOperationWith, policyWire, runtimeHandle } from "#runtime.ts"
+import { DbError, dbError } from "#runtime-errors.ts"
+import type { SchemaSpec } from "#spec.ts"
+
+function owned(operation: string, value: Uint8Array | null): Uint8Array {
+	if (value === null) {
+		throw dbError(operation, { _tag: "Internal" })
+	}
+	return value
+}
+
+/**
+ * Canonical schema admission for the migration generator: validates the
+ * spec natively and yields bounded JSON bytes carrying the canonical
+ * `schemaId` and the rendered schema snapshot.
+ */
+const internalMigrationSchema = Effect.fn("internalMigrationSchema")(function* (
+	spec: SchemaSpec,
+	work: ExecutionPolicy
+) {
+	const runtime = yield* runtimeHandle()
+	return yield* nativeOperationWith(
+		"internalMigrationSchema",
+		(callback) => dbNative.runtimeMigrationSchema(runtime, policyWire(work, "internalMigrationSchema"), spec, callback),
+		dbNative.runtimeBytesTake,
+		(bytes) => owned("internalMigrationSchema", bytes)
+	)
+})
+
+/**
+ * One bounded read-only migration-codec request (plan parse/validate/
+ * render/digest, manifest verify/append preview, plan-set digests): owned
+ * JSON request bytes in, owned JSON response bytes out.
+ */
+const internalMigrationRead = Effect.fn("internalMigrationRead")(function* (
+	request: Uint8Array,
+	work: ExecutionPolicy
+) {
+	if (!(request instanceof Uint8Array) || !(request.buffer instanceof ArrayBuffer)) {
+		return yield* Effect.fail(new DbError({ operation: "internalMigrationRead", reason: { _tag: "InvalidArgument" } }))
+	}
+	const runtime = yield* runtimeHandle()
+	return yield* nativeOperationWith(
+		"internalMigrationRead",
+		(callback) => dbNative.runtimeMigrationRead(runtime, policyWire(work, "internalMigrationRead"), request, callback),
+		dbNative.runtimeBytesTake,
+		(bytes) => owned("internalMigrationRead", bytes)
+	)
+})
+
+export { internalMigrationRead, internalMigrationSchema }