alinea 1.7.0 → 2.0.0-preview.1

package/dist/core/source/IndexedDBSource.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/IndexedDBSource.ts
 import { ShaMismatchError } from "./ShaMismatchError.js";
@@ -64,8 +64,9 @@ var IndexedDBSource = class {
           request.onerror = (event) => reject(event.target.error);
         })
       ]);
+      const availableBlobs = new Set(blobKeys);
       for (const sha of tree.shas) {
-        if (!blobKeys.includes(sha)) {
+        if (!availableBlobs.has(sha)) {
           console.warn(`Blob ${sha} in tree, but not found`);
           return ReadonlyTree.EMPTY;
         }
@@ -78,21 +79,34 @@ var IndexedDBSource = class {
     const current = await this.getTree();
     return current.sha === sha ? void 0 : current;
   }
-  async *getBlobs(shas) {
+  async *getBlobs(shas, options = {}) {
+    if (shas.length === 0) return;
     const db = await this.#connect();
     const transaction = db.transaction(["blobs"], "readonly");
     const store = transaction.objectStore("blobs");
-    for (const sha of shas) {
-      const request = store.get(sha);
-      yield new Promise((resolve, reject) => {
-        request.onsuccess = (event) => {
-          const entry = event.target.result;
-          if (entry) resolve([sha, entry]);
-          else reject(new Error(`Blob not found: ${sha}`));
-        };
+    const [keys, values] = await Promise.all([
+      new Promise((resolve, reject) => {
+        const request = store.getAllKeys();
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = (event) => reject(event.target.error);
+      }),
+      new Promise((resolve, reject) => {
+        const request = store.getAll();
+        request.onsuccess = () => resolve(request.result);
         request.onerror = (event) => reject(event.target.error);
-      });
+      })
+    ]);
+    const missing = new Set(shas);
+    for (let index = 0; index < keys.length; index++) {
+      if (options.signal?.aborted)
+        throw options.signal.reason ?? new Error("Blob transfer aborted");
+      const key = keys[index];
+      const value = values[index];
+      if (typeof key === "string" && value !== void 0 && missing.delete(key))
+        yield [key, value];
     }
+    const sha = missing.values().next().value;
+    if (sha !== void 0) throw new Error(`Blob not found: ${sha}`);
   }
   async applyChanges(batch) {
     const db = await this.#connect();

package/dist/core/source/MemorySource.d.ts

@@ -1,12 +1,12 @@
 import type { ChangesBatch } from './Change.js';
-import type { Source } from './Source.js';
+import type { GetBlobsOptions, Source } from './Source.js';
 import { ReadonlyTree } from './Tree.js';
 export declare class MemorySource implements Source {
     #private;
     constructor(tree?: ReadonlyTree, blobs?: Map<string, Uint8Array>);
     getTree(): Promise<ReadonlyTree>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
     addBlob(contents: Uint8Array): Promise<string>;
     applyChanges(batch: ChangesBatch): Promise<void>;
 }

package/dist/core/source/MemorySource.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/MemorySource.ts
 import { assert } from "../util/Assert.js";
@@ -18,8 +18,10 @@ var MemorySource = class {
   async getTreeIfDifferent(sha) {
     return this.#tree.sha === sha ? void 0 : this.#tree;
   }
-  async *getBlobs(shas) {
+  async *getBlobs(shas, options = {}) {
     for (const sha of shas) {
+      if (options.signal?.aborted)
+        throw options.signal.reason ?? new Error("Blob transfer aborted");
       const blob = this.#blobs.get(sha);
       assert(blob, `Blob not found: ${sha}`);
       yield [sha, blob];

package/dist/core/source/ShaMismatchError.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/ShaMismatchError.ts
 import { HttpError } from "../HttpError.js";
@@ -8,6 +8,8 @@ var ShaMismatchError = class extends HttpError {
     this.actual = actual;
     this.expected = expected;
   }
+  actual;
+  expected;
 };
 export {
   ShaMismatchError

package/dist/core/source/Source.d.ts

@@ -1,8 +1,11 @@
 import type { ChangesBatch } from './Change.js';
 import type { ReadonlyTree } from './Tree.js';
+export interface GetBlobsOptions {
+    signal?: AbortSignal;
+}
 export interface RemoteSource {
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
-    getBlobs(shas: Array<string>): AsyncGenerator<[sha: string, blob: Uint8Array]>;
+    getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncIterable<[sha: string, blob: Uint8Array]>;
 }
 export interface Source extends RemoteSource {
     getTree(): Promise<ReadonlyTree>;

package/dist/core/source/Source.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/Source.ts
 import { accumulate } from "../util/Async.js";

package/dist/core/source/SourceExport.js

@@ -1,8 +1,8 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/SourceExport.ts
-import * as base64 from "alinea/core/util/BufferToBase64";
-import { entries, fromEntries } from "alinea/core/util/Objects";
+import * as base64 from "../util/BufferToBase64.js";
+import { entries, fromEntries } from "../util/Objects.js";
 import { accumulate } from "../util/Async.js";
 import { MemorySource } from "./MemorySource.js";
 import { ReadonlyTree } from "./Tree.js";

package/dist/core/source/Tree.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/Tree.ts
 import { assert } from "../util/Assert.js";

package/dist/core/source/Utils.js

@@ -1,12 +1,9 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/source/Utils.ts
 import { crypto } from "@alinea/iso";
 async function sha1Bytes(data) {
-  const hashBuffer = await crypto.subtle.digest(
-    "SHA-1",
-    data
-  );
+  const hashBuffer = await crypto.subtle.digest("SHA-1", data);
   return new Uint8Array(hashBuffer);
 }
 async function sha1Hash(data) {

package/dist/core/util/Anchors.d.ts

@@ -0,0 +1,4 @@
+export declare function createUniqueAnchor(slug: string | undefined, anchors: Set<string>): string | undefined;
+export declare function isGeneratedAnchor(anchor: string | undefined, source: string): boolean;
+export declare function usedAnchors(anchors: Iterable<string>, current?: string): Set<string>;
+export declare function applyUrlSuffix(url: string, suffix: string | undefined, anchor: string | undefined): string;

package/dist/core/util/Anchors.js

@@ -0,0 +1,45 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/core/util/Anchors.ts
+function createUniqueAnchor(slug, anchors) {
+  if (!slug) return void 0;
+  let uniqueSlug = slug;
+  let count = 2;
+  while (anchors.has(uniqueSlug)) {
+    uniqueSlug = `${slug}-${count}`;
+    count += 1;
+  }
+  anchors.add(uniqueSlug);
+  return uniqueSlug;
+}
+function isGeneratedAnchor(anchor, source) {
+  if (anchor === void 0) return true;
+  if (!source) return false;
+  if (anchor === source) return true;
+  if (!anchor.startsWith(`${source}-`)) return false;
+  return /^[1-9]\d*$/.test(anchor.slice(source.length + 1));
+}
+function usedAnchors(anchors, current) {
+  const result = /* @__PURE__ */ new Set();
+  let currentCount = 0;
+  for (const anchor of anchors) {
+    result.add(anchor);
+    if (anchor === current) currentCount += 1;
+  }
+  if (current && currentCount <= 1) result.delete(current);
+  return result;
+}
+function applyUrlSuffix(url, suffix, anchor) {
+  const base = new URL("http://alinea.local");
+  const absolute = URL.canParse(url);
+  let result = new URL(url, base);
+  if (suffix?.trim()) result = new URL(suffix.trim(), result);
+  if (anchor?.trim()) result.hash = anchor.trim().replace(/^#+/, "");
+  return absolute ? result.href : `${result.pathname}${result.search}${result.hash}`;
+}
+export {
+  applyUrlSuffix,
+  createUniqueAnchor,
+  isGeneratedAnchor,
+  usedAnchors
+};

package/dist/core/util/ArrayBuffers.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/ArrayBuffers.ts
 import { base16 } from "./Encoding.js";

package/dist/core/util/Assert.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Assert.ts
 function assert(value, message) {

package/dist/core/util/Async.d.ts

@@ -1,4 +1,10 @@
-/** Accumulate all entries of an AsyncGenerator into an array */
-export declare function accumulate<T>(gen: AsyncGenerator<T>): Promise<Array<T>>;
+/** Accumulate all entries of an AsyncIterable into an array */
+export declare function accumulate<T>(gen: AsyncIterable<T>): Promise<Array<T>>;
 export declare function toGenerator<T>(iterable: Iterable<T>): AsyncGenerator<T>;
+export interface MapConcurrentOptions {
+    concurrency: number;
+    signal?: AbortSignal;
+}
+/** Map concurrently while yielding results as they complete. */
+export declare function mapConcurrent<T, TResult>(iterable: Iterable<T>, mapper: (item: T, signal?: AbortSignal) => Promise<TResult>, options: MapConcurrentOptions): AsyncGenerator<TResult>;
 export declare function genEffect<T, TReturn>(gen: AsyncIterable<T, TReturn>, effect: (result: T) => void): AsyncIterable<T>;

package/dist/core/util/Async.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Async.ts
 async function accumulate(gen) {
@@ -9,6 +9,72 @@ async function accumulate(gen) {
 async function* toGenerator(iterable) {
   for (const item of iterable) yield item;
 }
+async function* mapConcurrent(iterable, mapper, options) {
+  const { concurrency, signal } = options;
+  if (!Number.isInteger(concurrency) || concurrency < 1)
+    throw new RangeError("Concurrency must be a positive integer");
+  const remaining = iterable[Symbol.iterator]();
+  const completed = [];
+  let active = 0;
+  let stopped = signal?.aborted ?? false;
+  let failed = false;
+  let failure;
+  let wake;
+  function resume() {
+    const resolve = wake;
+    wake = void 0;
+    resolve?.();
+  }
+  function complete(result) {
+    active--;
+    if (stopped || failed) return;
+    completed.push(result);
+    resume();
+  }
+  function fail(error) {
+    active--;
+    if (stopped || failed) return;
+    failed = true;
+    failure = error;
+    resume();
+  }
+  function schedule() {
+    if (stopped || failed) return;
+    const next = remaining.next();
+    if (next.done) return;
+    active++;
+    try {
+      void mapper(next.value, signal).then(complete, fail);
+    } catch (error) {
+      fail(error);
+    }
+  }
+  function abort() {
+    stopped = true;
+    resume();
+  }
+  if (!stopped) signal?.addEventListener("abort", abort, { once: true });
+  try {
+    if (stopped) throw signal?.reason ?? new Error("Operation aborted");
+    for (let index = 0; index < concurrency; index++) schedule();
+    while (active > 0 || completed.length > 0 || stopped || failed) {
+      if (stopped) throw signal?.reason ?? new Error("Operation aborted");
+      if (failed) throw failure;
+      if (completed.length === 0) {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+        continue;
+      }
+      const result = completed.shift();
+      schedule();
+      yield result;
+    }
+  } finally {
+    stopped = true;
+    signal?.removeEventListener("abort", abort);
+  }
+}
 function genEffect(gen, effect) {
   return {
     [Symbol.asyncIterator]() {
@@ -37,5 +103,6 @@ function genEffect(gen, effect) {
 export {
   accumulate,
   genEffect,
+  mapConcurrent,
   toGenerator
 };

package/dist/core/util/BufferToBase64.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/BufferToBase64.ts
 import {

package/dist/core/util/Callable.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Callable.ts
 var { setPrototypeOf } = Object;

package/dist/core/util/Checks.js

@@ -1,7 +1,7 @@
 import {
   type
-} from "../../chunks/chunk-WD7H5L2L.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+} from "../../chunks/chunk-I4GC3E65.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Checks.ts
 import { keys } from "./Objects.js";

package/dist/core/util/CodeGen.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/CodeGen.ts
 function code(input, ...inserts) {
@@ -12,6 +12,8 @@ var Code = class {
     this.strings = strings;
     this.inserts = inserts;
   }
+  strings;
+  inserts;
   valueOf() {
     return this.toString();
   }

package/dist/core/util/ContentHash.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/ContentHash.ts
 import { crypto } from "@alinea/iso";

package/dist/core/util/Debounce.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Debounce.ts
 function debounce(func, delay) {

package/dist/core/util/DeepMap.d.ts

@@ -0,0 +1,14 @@
+export declare class DeepMap<Keys extends ReadonlyArray<unknown>, Value> {
+    #private;
+    constructor(entries?: ReadonlyArray<readonly [Keys, Value]> | null);
+    get size(): number;
+    get(keys: Keys): Value | undefined;
+    set(keys: Keys, value: Value): this;
+    has(keys: Keys): boolean;
+    delete(keys: Keys): boolean;
+    clear(): void;
+    keys(): IterableIterator<Keys>;
+    values(): IterableIterator<Value>;
+    entries(): IterableIterator<[Keys, Value]>;
+    [Symbol.iterator](): IterableIterator<[Keys, Value]>;
+}

package/dist/core/util/DeepMap.js

@@ -0,0 +1,75 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/core/util/DeepMap.ts
+var DeepMap = class {
+  #tree = /* @__PURE__ */ new Map();
+  #values = /* @__PURE__ */ new Map();
+  constructor(entries) {
+    if (entries) for (const entry of entries) this.set(...entry);
+  }
+  get size() {
+    return this.#values.size;
+  }
+  get(keys) {
+    const branch = this.#getBranch(keys);
+    if (!branch) return;
+    return this.#values.get(branch);
+  }
+  #getBranch(keys) {
+    let branch = this.#tree;
+    for (const key of keys) {
+      if (!branch.has(key)) return;
+      branch = branch.get(key);
+    }
+    return branch;
+  }
+  set(keys, value) {
+    let branch = this.#tree;
+    for (const key of keys) {
+      if (branch.has(key)) branch = branch.get(key);
+      else branch.set(key, branch = /* @__PURE__ */ new Map());
+    }
+    this.#values.set(branch, value);
+    return this;
+  }
+  has(keys) {
+    const branch = this.#getBranch(keys);
+    if (!branch) return false;
+    return this.#values.has(branch);
+  }
+  delete(keys) {
+    const branch = this.#getBranch(keys);
+    if (!branch) return false;
+    return this.#values.delete(branch);
+  }
+  clear() {
+    this.#clearBranch(this.#tree);
+  }
+  #clearBranch(branch) {
+    if (this.#values.has(branch)) this.#values.delete(branch);
+    for (const map of branch.values()) this.#clearBranch(map);
+    return branch.clear();
+  }
+  *keys() {
+    yield* this.#keysOfBranch(this.#tree);
+  }
+  *#keysOfBranch(branch, keys = []) {
+    for (const [key, map] of branch) {
+      const current = keys.concat(key);
+      if (this.#values.has(map)) yield current;
+      yield* this.#keysOfBranch(map, current);
+    }
+  }
+  *values() {
+    yield* this.#values.values();
+  }
+  *entries() {
+    for (const keys of this.keys()) yield [keys, this.get(keys)];
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+export {
+  DeepMap
+};

package/dist/core/util/Encoding.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Encoding.ts
 function parse(string, encoding, opts = {}) {

package/dist/core/util/EntryFilenames.d.ts

@@ -1,7 +1,6 @@
 import type { Config } from '../Config.js';
 import { type Entry, type EntryStatus } from '../Entry.js';
-import type { EntryUrlMeta, Type } from '../Type.js';
-export declare function workspaceMediaDir(config: Config, workspace: string): string;
+import type { EntryUrlInput, Type } from '../Type.js';
 export declare function entryInfo(fileName: string): [name: string, status: EntryStatus];
 export declare function entryChildrenDir(config: Config, entry: {
     workspace: string;
@@ -25,7 +24,7 @@ export declare function entryFileName(config: Config, entry: {
     status: EntryStatus;
 }, parentPaths: Array<string>): string;
 export declare function entryFile(config: Config, entry: Entry): string;
-export declare function entryUrl(type: Type, meta: EntryUrlMeta): string;
+export declare function entryUrl(type: Type, meta: EntryUrlInput): string;
 export declare function pathSuffix(path: string, conflictingPaths: Array<string>): number | undefined;
 export declare function applySuffix(path: string, suffix: number): string;
 export declare function fileVersions(file: string): string[];

package/dist/core/util/EntryFilenames.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/EntryFilenames.ts
 import * as paths from "alinea/core/util/Paths";
@@ -9,9 +9,6 @@ import {
 import { getRoot, getType } from "../Internal.js";
 import { Workspace } from "../Workspace.js";
 import { join } from "./Paths.js";
-function workspaceMediaDir(config, workspace) {
-  return Workspace.data(config.workspaces[workspace])?.mediaDir ?? "";
-}
 function entryInfo(fileName) {
   const status = ALT_STATUS.find((s) => fileName.endsWith(`.${s}`));
   if (status) return [fileName.slice(0, -status.length - 1), status];
@@ -63,12 +60,12 @@ function entryFile(config, entry) {
   return join(contentDir, entry.root, filePath);
 }
 function entryUrl(type, meta) {
-  const { entryUrl: entryUrl2 } = getType(type);
-  if (entryUrl2) return entryUrl2(meta);
   const segments = meta.locale ? [meta.locale.toLowerCase()] : [];
-  return `/${segments.concat(
+  const defaultUrl = `/${segments.concat(
     meta.parentPaths.concat(meta.path).filter((segment) => segment !== "index" && segment !== "")
   ).join("/")}`;
+  const { entryUrl: entryUrl2 } = getType(type);
+  return entryUrl2 ? entryUrl2({ ...meta, defaultUrl }) : defaultUrl;
 }
 function pathSuffix(path, conflictingPaths) {
   if (conflictingPaths.includes(path)) {
@@ -99,6 +96,5 @@ export {
   entryInfo,
   entryUrl,
   fileVersions,
-  pathSuffix,
-  workspaceMediaDir
+  pathSuffix
 };

package/dist/core/util/EntryRows.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/EntryRows.ts
 import { JsonLoader } from "alinea/backend/loader/JsonLoader";

package/dist/core/util/FractionalIndexing.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/FractionalIndexing.ts
 var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

package/dist/core/util/GetRandomColor.js

@@ -1,26 +1,26 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/GetRandomColor.ts
 var COLORS = [
-  "#EA9280",
-  "#EB9091",
-  "#E58FB1",
-  "#E38EC3",
-  "#CF91D8",
-  "#AA99EC",
-  "#5EB0EF",
-  "#3DB9CF",
-  "#53B9AB",
-  "#5BB98C",
-  "#65BA75",
-  "#D09E72",
-  "#FA934E",
-  "#2EBDE5",
-  "#40C4AA",
-  "#94BA2C",
-  "#EBBC00",
-  "#EE9D2B",
-  "#B8A383"
+  "#E94427",
+  "#E72F53",
+  "#E11F82",
+  "#D21CA6",
+  "#A92ED3",
+  "#7741DE",
+  "#1F7FE3",
+  "#00A0C6",
+  "#00A98A",
+  "#14B65C",
+  "#2CB93F",
+  "#CD771F",
+  "#EC730A",
+  "#00A9D6",
+  "#00B48A",
+  "#88B800",
+  "#E0AE00",
+  "#E9840A",
+  "#AD8A47"
 ];
 function getRandomColor(sub) {
   let hashCode = 0;

package/dist/core/util/Identifiers.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Identifiers.ts
 var validIdentifier = /^[A-Za-z][A-Za-z0-9_]*$/;

package/dist/core/util/JWT.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/JWT.ts
 import { crypto } from "@alinea/iso";

package/dist/core/util/Lazy.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Lazy.ts
 var Lazy;

package/dist/core/util/LazyRecord.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/LazyRecord.ts
 import { Lazy } from "./Lazy.js";

package/dist/core/util/Logger.js

@@ -1,7 +1,7 @@
 import {
   prettyMilliseconds
 } from "../../chunks/chunk-4LUHJRX4.js";
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Logger.ts
 var consoleLog = console.log.bind(console);
@@ -40,6 +40,7 @@ var Logger = class _Logger {
   constructor(name) {
     this.name = name;
   }
+  name;
   logs = [];
   started = now();
   operations = [];