@e280/quay 0.0.0-1

package/s/logic/aspects/dropzone.ts

@@ -0,0 +1,77 @@
+import {ShockDragDrop, signal} from "@benev/slate"
+
+import {Group} from "../group.js"
+import {CodexItem} from "./codex/parts/codex-item.js"
+
+export class Dropzone {
+	#drag_drop = new ShockDragDrop<CodexItem, CodexItem>({
+		handle_drop: (_e, grabbed, hovering) => this.group.move(grabbed, hovering)
+	})
+
+	constructor(private group: Group) {}
+
+	// to make drop file to import ui work
+	#hovering = signal<CodexItem | undefined>(undefined)
+
+	get grabbed() {
+		return this.#drag_drop.grabbed
+	}
+
+	get hovering() {
+		return this.#drag_drop.hovering ?? this.#hovering.value
+	}
+
+	dragenter = (e: DragEvent, target?: CodexItem) => {
+		e.preventDefault()
+		this.#drag_drop.dropzone.dragenter()(e)
+		this.#hovering.value = target
+	}
+
+	dragleave = (e: DragEvent) => {
+		this.#drag_drop.dropzone.dragleave()(e)
+		this.#hovering.value = undefined
+	}
+
+	dragstart = (e: DragEvent, n: CodexItem) => {
+		e.stopPropagation()
+		this.#drag_drop.dragzone.dragstart(n)(e)
+	}
+
+	dragover = (e: DragEvent, n: CodexItem) => {
+		e.preventDefault()
+		this.#drag_drop.dropzone.dragover(n)(e)
+	}
+
+	dragend = (e: DragEvent) => {
+		this.#drag_drop.dragzone.dragend()(e)
+		this.#hovering.value = undefined
+	}
+
+	drop = (e: DragEvent, target: CodexItem) => {
+		e.preventDefault()
+		const files = Array.from(e.dataTransfer?.files || [])
+
+		if (files.length) {
+			this.group.upload(files, target)
+		}
+
+		const same = this.grabbed?.id === this.hovering?.id
+		const child = this.grabbed?.children.some(c => this.hovering?.id === c.id)
+		const parent = this.grabbed?.parent?.id === this.hovering?.id
+
+		if(!same && !child && !parent)
+			this.#drag_drop.dropzone.drop(target)(e)
+
+		this.#hovering.value = undefined
+	}
+
+	change = (e: DragEvent, targetFolder: CodexItem) => {
+		const input = e.currentTarget as HTMLInputElement
+		const files = Array.from(input.files ?? [])
+
+		if (files.length) {
+			this.group.upload(files, targetFolder)
+		}
+	}
+}
+

package/s/logic/aspects/tree-trail.ts

@@ -0,0 +1,33 @@
+import {signal} from "@benev/slate"
+import {Schema} from "./codex/parts/types.js"
+import {CodexItem} from "./codex/parts/codex-item.js"
+
+export class TreeTrail<Sc extends Schema> {
+	readonly signal = signal<CodexItem<Sc>[]>([])
+
+	constructor(root: CodexItem<Sc>) {
+		this.signal.value = [root]
+	}
+
+	setTrail(e: Event, item: CodexItem<Sc>) {
+		if (e.target !== e.currentTarget) return
+
+		const trail: CodexItem<Sc>[] = []
+
+		let cur = item.kind === "folder"
+			? item
+			: item.parent
+
+		while (cur) {
+			trail.unshift(cur)
+			cur = cur.parent
+		}
+
+		this.signal.value = trail
+	}
+
+	get currentFolder() {
+		return this.signal.value.at(-1)?.children ?? []
+	}
+}
+

package/s/logic/brain.ts

@@ -0,0 +1,22 @@
+
+import {MapG} from "@e280/stz"
+import {Group} from "./group.js"
+
+/**
+ * Quay's global state
+ *  - manages groups
+ *  - each group is a different hierarchy, which can have unique types and stuff
+ */
+export class Brain {
+	#groups = new MapG<string, Group>()
+
+	setGroup<G extends Group>(name: string, group: G) {
+		this.#groups.set(name, group)
+		return group
+	}
+
+	getGroup<G extends Group>(name: string) {
+		return this.#groups.require(name) as G
+	}
+}
+

package/s/logic/group.ts

@@ -0,0 +1,104 @@
+import {sub} from "@e280/stz"
+import {signal} from "@benev/slate"
+
+import {Permission} from "./permissions.js"
+import {Dropzone} from "./aspects/dropzone.js"
+import {TreeTrail} from "./aspects/tree-trail.js"
+import {Schema} from "./aspects/codex/parts/types.js"
+import {GroupConfig, SearchFn, SortFn} from "./types.js"
+import {CodexItem} from "./aspects/codex/parts/codex-item.js"
+
+export class Group<Sc extends Schema = any> {
+	trail: TreeTrail<Sc>
+	dropzone = new Dropzone(this)
+	searchText = signal("")
+	selectedFilter = signal("")
+	selectedSort = signal("")
+
+	on = {
+		newFolder: sub<[{parent: CodexItem<Sc>}]>(),
+		move: sub<[{item: CodexItem<Sc>, target: CodexItem<Sc>}]>(),
+		delete: sub<[{item: CodexItem<Sc>}]>(),
+		rename: sub<[{item: CodexItem<Sc>, newName: string}]>(),
+		upload: sub<[{files: File[], target: CodexItem<Sc>}]>(),
+		search: sub<[{terms: string[]}]>(),
+		refresh: sub<[{}]>(),
+	}
+
+	constructor(public config: GroupConfig<Sc>) {
+		this.selectedFilter.value = config.defaultFilter
+		this.selectedSort.value = config.defaultSort
+		this.trail = new TreeTrail(config.root)
+	}
+
+	get permissions() {
+		return this.config.permissions as (item: CodexItem) => Permission
+	}
+
+	getFilterFn(filterKey: string): SearchFn<Sc> {
+		return this.config.filters.get(filterKey) ?? (() => true)
+	}
+
+	getSearchFn(searchText: string): SearchFn<Sc> {
+		const terms = searchText.trim().toLowerCase().split(/\s+/)
+		return item => this.config.search(terms, item)
+	}
+
+	getSortFn(sortKey: string): SortFn<Sc> {
+		return this.config.sorts?.get(sortKey) ?? (() => 0)
+	}
+
+	sort(items: CodexItem<Sc>[]): CodexItem<Sc>[] {
+		const sortFn = this.getSortFn(this.selectedSort.value)
+		return [...items].sort(sortFn)
+	}
+
+	matches(item: CodexItem<Sc>) {
+		const filterFn = this.getFilterFn(this.selectedFilter.value)
+		const searchFn = this.getSearchFn(this.searchText.value)
+		return filterFn(item) && searchFn(item)
+	}
+
+	move(item: CodexItem<Sc>, target: CodexItem<Sc>) {
+		if(!this.permissions(item).move)
+			throw new Error("move permission not granted")
+
+		item.detach()
+		target.attach(item)
+
+		this.on.move.pub({item, target})
+	}
+
+	delete(item: CodexItem<Sc>) {
+		if(!this.permissions(item).delete)
+			throw new Error("delete permission not granted")
+
+		item.destroy()
+
+		this.on.delete.pub({item})
+	}
+
+	rename(item: CodexItem<Sc>, newName: string) {
+		if(!this.permissions(item).rename)
+			throw new Error("rename permission not granted")
+
+		this.on.rename.pub({item, newName})
+	}
+
+	upload(files: File[], folder: CodexItem<Sc>) {
+		if(!this.permissions(folder).upload)
+			throw new Error("upload permission not granted")
+
+		this.on.upload.pub({files, target: folder})
+	}
+
+	addFolder(parent: CodexItem<Sc>) {
+		if(!this.permissions(parent).newFolder)
+			throw new Error("add folder permission not granted")
+
+		this.on.newFolder.pub({parent})
+	}
+
+	components = () => this.components
+}
+

package/s/logic/permissions.ts

@@ -0,0 +1,34 @@
+enum PermissionKey {
+	rename = "rename",
+	move = "move",
+	delete = "delete",
+	refresh = "refresh",
+	newFolder = "newFolder",
+	search = "search",
+	upload = "upload"
+}
+
+export type Permission = {
+	[K in PermissionKey]: boolean
+}
+
+const ALL_KEYS = Object.values(PermissionKey) as PermissionKey[]
+
+function makePermissions(
+	defaultValue: boolean,
+	overrides: Partial<Permission> = {}
+): Permission {
+	const perms = {} as Permission
+	for (const key of ALL_KEYS)
+		perms[key] = key in overrides ? overrides[key]! : defaultValue
+	return perms
+}
+
+export const Permissions = {
+	all: makePermissions(true),
+	readOnly: makePermissions(false, {
+		[PermissionKey.refresh]: true,
+		[PermissionKey.search]: true,
+	}),
+	none: makePermissions(false),
+}

package/s/logic/presets/media/group.ts

@@ -0,0 +1,94 @@
+
+import {MapG} from "@e280/stz"
+import {Content, html} from "@benev/slate"
+
+import Quay from "../../../index.js"
+import {Group} from "../../group.js"
+import {Codex} from "../../aspects/codex/codex.js"
+import {MediaFormat, MediaSchema} from "./schema.js"
+import {GroupConfig, SearchFn, SortFn} from "../../types.js"
+import {CodexItem} from "../../aspects/codex/parts/codex-item.js"
+
+export class MediaGroup extends Group<MediaSchema> implements Group {
+	static config = (): GroupConfig<MediaSchema> => {
+		const formatIcons = new MapG<MediaFormat, Content>()
+			.set("audio", html`<sl-icon name=music-note-beamed></sl-icon>`)
+			.set("video", html`<sl-icon name=film></sl-icon>`)
+			.set("image", html`<sl-icon name=image></sl-icon>`)
+			.set("other", html`<sl-icon name=file-earmark></sl-icon>`)
+
+		const filters = new Map<string, SearchFn<MediaSchema>>()
+			.set("all", () => true)
+			.set("video", item => item.isKind("folder") || (item.isKind("file") && item.specimen.format === "video"))
+			.set("audio", item => item.isKind("folder") || (item.isKind("file") && item.specimen.format === "audio"))
+
+		const sorts = new Map<string, SortFn<MediaSchema>>()
+			.set("label", (a, b) => a.specimen.label.localeCompare(b.specimen.label))
+			.set("format", (a, b) => {
+				if (a.isKind("file") && b.isKind("file"))
+					return a.specimen.format.localeCompare(b.specimen.format)
+
+				if (a.isKind("file")) return -1
+				if (b.isKind("file")) return 1
+
+				return 0
+			})
+
+		const search: (terms: string[], item: CodexItem<MediaSchema>) => boolean = (terms, item) => {
+			const query = terms.join(" ").trim().toLowerCase()
+			if (query === "") return true
+
+			if (item.kind === "folder") {
+				return item.children.some(child => search(terms, child))
+			}
+
+			return item.specimen.label.toLowerCase().includes(query)
+		}
+
+		const codex = Codex.setup<MediaSchema>({
+			folder: {icon: html`<sl-icon name="folder"></sl-icon>`},
+			file: {icon: html`<sl-icon name="file"></sl-icon>`},
+		})
+
+		const root = codex.root(
+			codex.create("folder", {label: "project"})
+		)
+
+		const renderIcon = (item: CodexItem<MediaSchema>, opened: boolean) => {
+			return item.isKind("file")
+				? formatIcons.require(item.specimen.format)
+				: opened ? html`<sl-icon name="folder2-open"></sl-icon>` : item.taxon.icon
+		}
+
+		return {
+			codex,
+			root,
+			sorts,
+			filters: filters,
+			defaultFilter: "all",
+			defaultSort: "label",
+			search: (terms, item) => {
+				return terms.some(term => (
+					item.kind.includes(term) ||
+					item.id.includes(term) ||
+					item.specimen.label.includes(term)
+				)) || search(terms, item)
+			},
+			renderIcon,
+			renderLabel: item => item.specimen.label,
+			renderPreview: (item: CodexItem<MediaSchema>) => {
+				return (item.isKind("file") && item.specimen.previewUrl)
+					? html`<img src=${item.specimen.previewUrl}>`
+					: renderIcon(item, false)
+					// // TODO icons
+					// : html`<sl-icon name=${item.taxon.icon}></sl-icon>`
+			},
+			permissions: item => Quay.permissions.all,
+		}
+	}
+
+	constructor() {
+		super(MediaGroup.config())
+	}
+}
+

package/s/logic/presets/media/schema.ts

@@ -0,0 +1,22 @@
+
+import {Content} from "@benev/slate"
+import {AsSchema} from "../../aspects/codex/parts/types.js"
+
+export type MediaFormat = "video" | "image" | "audio" | "other"
+
+export type MediaSchema = AsSchema<{
+	taxon: {
+		icon: Content
+	}
+	specimens: {
+		folder: {
+			label: string
+		}
+		file: {
+			label: string
+			format: MediaFormat
+			previewUrl: string | null
+		}
+	}
+}>
+

package/s/logic/presets/opfs/schema.ts

@@ -0,0 +1,21 @@
+
+import {Content} from "@benev/slate"
+import {AsSchema} from "../../aspects/codex/parts/types.js"
+
+export type OpfsSchema = AsSchema<{
+	taxon: {
+		icon: Content
+	}
+	specimens: {
+		directory: {
+			label: string
+		}
+		file: {
+			label: string
+			size: string
+			type: string
+			lastModified: number
+		}
+	}
+}>
+

package/s/logic/presets/plain/group.ts

@@ -0,0 +1,44 @@
+
+import Quay from "../../../index.js"
+import {Group} from "../../group.js"
+import {PlainSchema} from "./schema.js"
+import {GroupConfig, SortFn} from "../../types.js"
+import {Codex} from "../../aspects/codex/codex.js"
+
+export class PlainGroup extends Group<PlainSchema> {
+	static config = (): GroupConfig<PlainSchema> => {
+		const codex = Codex.setup<PlainSchema>({
+			item: {icon: "📄"},
+		})
+
+		const root = codex.root(
+			codex.create("item", {label: "root"})
+		)
+
+		return {
+			codex,
+			root,
+			defaultSort: "id",
+			sorts: new Map<string, SortFn<PlainSchema>>()
+				.set("label", (a, b) => a.id.localeCompare(b.id)),
+			defaultFilter: "all",
+			filters: new Map()
+				.set("all", () => true),
+			search: (terms, item) => {
+				return terms.some(term => (
+					item.kind.includes(term) ||
+					item.id.includes(term)
+				))
+			},
+			renderLabel: item => item.id,
+			renderIcon: item => item.taxon.icon,
+			renderPreview: () => null,
+			permissions: item => Quay.permissions.all,
+		}
+	}
+
+	constructor() {
+		super(PlainGroup.config())
+	}
+}
+

package/s/logic/presets/plain/schema.ts

@@ -0,0 +1,15 @@
+
+import {Content} from "@benev/slate"
+import {AsSchema} from "../../aspects/codex/parts/types.js"
+
+export type PlainSchema = AsSchema<{
+	taxon: {
+		icon: Content
+	}
+	specimens: {
+		item: {
+			label: string
+		}
+	}
+}>
+

package/s/logic/types.ts

@@ -0,0 +1,33 @@
+
+import {Permission} from "./permissions.js"
+import {Codex} from "./aspects/codex/codex.js"
+import {Schema} from "./aspects/codex/parts/types.js"
+import {CodexItem} from "./aspects/codex/parts/codex-item.js"
+import { Content } from "@benev/slate"
+
+export type SearchFn<Sc extends Schema> = (item: CodexItem<Sc>) => boolean
+export type SortFn<Sc extends Schema> = (a: CodexItem<Sc>, b: CodexItem<Sc>) => number
+
+export interface GroupConfig<Sc extends Schema> {
+	codex: Codex<Sc>
+	root: CodexItem<Sc>
+	defaultFilter: string
+	filters: Map<string, SearchFn<Sc>>
+	defaultSort: string
+	sorts: Map<string, SortFn<Sc>>
+	search: (terms: string[], item: CodexItem<Sc>) => boolean
+	renderIcon: (item: CodexItem<Sc>, opened: boolean) => Content
+	renderLabel: (item: CodexItem<Sc>) => Content
+	renderPreview: (item: CodexItem<Sc>) => Content
+	permissions: (item: CodexItem<Sc>) => Permission
+}
+
+// export interface GroupActions<Sc extends Schema> {
+// 	newFolder: (parent: CodexItem<Sc>) => Promise<void>
+// 	move: (item: CodexItem<Sc>, target: CodexItem<Sc>) => Promise<void>
+// 	delete: (item: CodexItem<Sc>) => Promise<void>
+// 	rename: (item: CodexItem<Sc>, newName: string) => Promise<void>
+// 	upload: (files: File[], target: CodexItem<Sc>) => Promise<void>
+// 	search: (terms: string[]) => Promise<CodexItem<Sc>[]>
+// 	refresh: () => Promise<void>
+// }

package/s/tests.test.ts

@@ -0,0 +1,8 @@
+
+import {Science} from "@e280/science"
+import cellar from "./cellar/cellar.test.js"
+
+await Science.run({
+	cellar,
+})
+

package/x/cellar/cask.d.ts

@@ -0,0 +1,8 @@
+/** File with a hash label */
+export declare class Cask {
+    hash: string;
+    bytes: Uint8Array;
+    static hash(bytes: Uint8Array): Promise<string>;
+    static make(bytes: Uint8Array): Promise<Cask>;
+    constructor(hash: string, bytes: Uint8Array);
+}

package/x/cellar/cask.js

@@ -0,0 +1,19 @@
+import { Hex } from "@e280/stz";
+/** File with a hash label */
+export class Cask {
+    hash;
+    bytes;
+    static async hash(bytes) {
+        const hashBuffer = await crypto.subtle.digest("SHA-256", bytes);
+        return Hex.fromBytes(new Uint8Array(hashBuffer));
+    }
+    static async make(bytes) {
+        const hash = await this.hash(bytes);
+        return new this(hash, bytes);
+    }
+    constructor(hash, bytes) {
+        this.hash = hash;
+        this.bytes = bytes;
+    }
+}
+//# sourceMappingURL=cask.js.map

package/x/cellar/cask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cask.js","sourceRoot":"","sources":["../../s/cellar/cask.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,GAAG,EAAC,MAAM,WAAW,CAAA;AAE7B,6BAA6B;AAC7B,MAAM,OAAO,IAAI;IAWG;IAAqB;IAVxC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAiB;QAClC,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;QAC/D,OAAO,GAAG,CAAC,SAAS,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAA;IACjD,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,KAAiB;QAClC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACnC,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC7B,CAAC;IAED,YAAmB,IAAY,EAAS,KAAiB;QAAtC,SAAI,GAAJ,IAAI,CAAQ;QAAS,UAAK,GAAL,KAAK,CAAY;IAAG,CAAC;CAC7D"}

package/x/cellar/cellar.d.ts

@@ -0,0 +1,22 @@
+import { Cask } from "./cask.js";
+import { Forklift } from "./forklift.js";
+/**
+ * Cellar is an immutable content-addressable file store
+ *  - files are identified by their hashes (duplicates are impossible)
+ *  - files cannot be modified (delete it and save another)
+ *  - no filenames or metadata (store those somewhere else)
+ *  - pass in a forklift, which is the backend that actually stores the data
+ *    - MemoryForklift is the default
+ *    - OpfsForklift is probably what you really want in the browser
+ */
+export declare class Cellar {
+    private forklift;
+    static opfs(dirname?: string): Promise<Cellar>;
+    constructor(forklift?: Forklift);
+    list(): AsyncIterable<string>;
+    has(hash: string): Promise<boolean>;
+    save(bytes: Uint8Array): Promise<void>;
+    load(hash: string): Promise<Cask>;
+    delete(hash: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/x/cellar/cellar.js

@@ -0,0 +1,47 @@
+import { Cask } from "./cask.js";
+import { OpfsForklift } from "./opfs-forklift.js";
+import { MemoryForklift } from "./memory-forklift.js";
+/**
+ * Cellar is an immutable content-addressable file store
+ *  - files are identified by their hashes (duplicates are impossible)
+ *  - files cannot be modified (delete it and save another)
+ *  - no filenames or metadata (store those somewhere else)
+ *  - pass in a forklift, which is the backend that actually stores the data
+ *    - MemoryForklift is the default
+ *    - OpfsForklift is probably what you really want in the browser
+ */
+export class Cellar {
+    forklift;
+    static async opfs(dirname = "cellar") {
+        return new this(await OpfsForklift.setup(dirname));
+    }
+    constructor(forklift = new MemoryForklift()) {
+        this.forklift = forklift;
+    }
+    async *list() {
+        yield* this.forklift.list();
+    }
+    async has(hash) {
+        return this.forklift.has(hash);
+    }
+    async save(bytes) {
+        const cask = await Cask.make(bytes);
+        if (!await this.forklift.has(cask.hash))
+            await this.forklift.save(cask.hash, cask.bytes);
+    }
+    async load(hash) {
+        const bytes = await this.forklift.load(hash);
+        const cask = await Cask.make(bytes);
+        if (cask.hash !== hash)
+            throw new Error(`corruption error, hash mismatch (requested ${hash}) (got ${cask.hash})`);
+        return cask;
+    }
+    async delete(hash) {
+        await this.forklift.delete(hash);
+    }
+    async clear() {
+        for await (const hash of this.list())
+            await this.delete(hash);
+    }
+}
+//# sourceMappingURL=cellar.js.map

package/x/cellar/cellar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cellar.js","sourceRoot":"","sources":["../../s/cellar/cellar.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAA;AAE9B,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAA;AAC/C,OAAO,EAAC,cAAc,EAAC,MAAM,sBAAsB,CAAA;AAEnD;;;;;;;;GAQG;AACH,MAAM,OAAO,MAAM;IAKE;IAJpB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,QAAQ;QACnC,OAAO,IAAI,IAAI,CAAC,MAAM,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,YAAoB,WAAqB,IAAI,cAAc,EAAE;QAAzC,aAAQ,GAAR,QAAQ,CAAiC;IAAG,CAAC;IAEjE,KAAK,CAAC,CAAC,IAAI;QACV,KAAK,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAA;IAC5B,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,KAAiB;QAC3B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACnC,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;YACtC,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IACjD,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAY;QACtB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAC5C,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACnC,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,IAAI,UAAU,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;QACjH,OAAO,IAAI,CAAA;IACZ,CAAC;IAED,KAAK,CAAC,MAAM,CAAC,IAAY;QACxB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACjC,CAAC;IAED,KAAK,CAAC,KAAK;QACV,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE;YACnC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACzB,CAAC;CACD"}

package/x/cellar/cellar.test.d.ts

@@ -0,0 +1,11 @@
+import { Science } from "@e280/science";
+declare const _default: {
+    "save + load roundtrip": Science.Test;
+    "save is idempotent": Science.Test;
+    "throws on corruption": Science.Test;
+    "delete removes file": Science.Test;
+    "load missing throws": Science.Test;
+    "list returns saved hashes": Science.Test;
+    "clear removes all entries": Science.Test;
+};
+export default _default;