@mulmoclaude/collection-plugin 0.5.8 → 0.5.9

package/dist/server/discovery.d.ts

@@ -1,228 +0,0 @@
-import { z } from "zod";
-import type { LoadedCollection } from "./discoveredCollection";
-import type { CollectionDetail, CollectionSchema, CollectionSource, CollectionSummary } from "../core/schema";
-export declare const CollectionSchemaZ: z.ZodObject<{
-    title: z.ZodString;
-    icon: z.ZodString;
-    dataPath: z.ZodString;
-    primaryKey: z.ZodString;
-    singleton: z.ZodOptional<z.ZodString>;
-    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
-        type: z.ZodEnum<{
-            string: "string";
-            number: "number";
-            boolean: "boolean";
-            text: "text";
-            email: "email";
-            date: "date";
-            datetime: "datetime";
-            markdown: "markdown";
-            ref: "ref";
-            money: "money";
-            enum: "enum";
-            table: "table";
-            derived: "derived";
-            embed: "embed";
-            image: "image";
-            file: "file";
-            toggle: "toggle";
-        }>;
-        label: z.ZodString;
-        primary: z.ZodOptional<z.ZodBoolean>;
-        required: z.ZodOptional<z.ZodBoolean>;
-        to: z.ZodOptional<z.ZodString>;
-        id: z.ZodOptional<z.ZodString>;
-        currency: z.ZodOptional<z.ZodString>;
-        currencyField: z.ZodOptional<z.ZodString>;
-        values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        field: z.ZodOptional<z.ZodString>;
-        onValue: z.ZodOptional<z.ZodString>;
-        offValue: z.ZodOptional<z.ZodString>;
-        of: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                text: "text";
-                email: "email";
-                date: "date";
-                datetime: "datetime";
-                markdown: "markdown";
-                ref: "ref";
-                money: "money";
-                enum: "enum";
-            }>;
-            label: z.ZodString;
-            required: z.ZodOptional<z.ZodBoolean>;
-            to: z.ZodOptional<z.ZodString>;
-            currency: z.ZodOptional<z.ZodString>;
-            currencyField: z.ZodOptional<z.ZodString>;
-            values: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>;
-        formula: z.ZodOptional<z.ZodString>;
-        display: z.ZodOptional<z.ZodEnum<{
-            string: "string";
-            number: "number";
-            date: "date";
-            money: "money";
-        }>>;
-        when: z.ZodOptional<z.ZodObject<{
-            field: z.ZodString;
-            in: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        icon: z.ZodOptional<z.ZodString>;
-        kind: z.ZodEnum<{
-            chat: "chat";
-        }>;
-        role: z.ZodString;
-        template: z.ZodString;
-        when: z.ZodOptional<z.ZodObject<{
-            field: z.ZodString;
-            in: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-    collectionActions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        icon: z.ZodOptional<z.ZodString>;
-        kind: z.ZodEnum<{
-            chat: "chat";
-        }>;
-        role: z.ZodString;
-        template: z.ZodString;
-        when: z.ZodOptional<z.ZodObject<{
-            field: z.ZodString;
-            in: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-    completionField: z.ZodOptional<z.ZodString>;
-    completionDoneValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    displayField: z.ZodOptional<z.ZodString>;
-    triggerField: z.ZodOptional<z.ZodString>;
-    triggerLeadDays: z.ZodOptional<z.ZodNumber>;
-    spawn: z.ZodOptional<z.ZodObject<{
-        when: z.ZodOptional<z.ZodObject<{
-            field: z.ZodString;
-            in: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-        every: z.ZodUnion<readonly [z.ZodObject<{
-            unit: z.ZodEnum<{
-                day: "day";
-                week: "week";
-                month: "month";
-                year: "year";
-            }>;
-            interval: z.ZodNumber;
-            dayOfMonth: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"last">]>>;
-        }, z.core.$strict>, z.ZodObject<{
-            fromField: z.ZodString;
-            map: z.ZodRecord<z.ZodString, z.ZodObject<{
-                unit: z.ZodEnum<{
-                    day: "day";
-                    week: "week";
-                    month: "month";
-                    year: "year";
-                }>;
-                interval: z.ZodNumber;
-                dayOfMonth: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"last">]>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>]>;
-        carry: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        set: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>;
-    calendarField: z.ZodOptional<z.ZodString>;
-    calendarEndField: z.ZodOptional<z.ZodString>;
-    calendarTimeField: z.ZodOptional<z.ZodString>;
-    kanbanField: z.ZodOptional<z.ZodString>;
-    views: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        icon: z.ZodOptional<z.ZodString>;
-        file: z.ZodString;
-        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-            read: "read";
-            write: "write";
-        }>>>;
-    }, z.core.$strip>>>;
-    notifyWhen: z.ZodOptional<z.ZodObject<{
-        field: z.ZodString;
-        in: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-    ingest: z.ZodOptional<z.ZodObject<{
-        kind: z.ZodEnum<{
-            rss: "rss";
-            atom: "atom";
-            "http-json": "http-json";
-        }>;
-        url: z.ZodString;
-        schedule: z.ZodEnum<{
-            hourly: "hourly";
-            daily: "daily";
-            weekly: "weekly";
-            "on-demand": "on-demand";
-        }>;
-        itemsAt: z.ZodOptional<z.ZodString>;
-        map: z.ZodRecord<z.ZodString, z.ZodString>;
-        idFrom: z.ZodOptional<z.ZodString>;
-        maxItems: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** Result of the post-Zod acceptance gates: the resolved record dir on
- *  success, or a one-line reason discovery would skip the schema. */
-export type SchemaAcceptance = {
-    ok: true;
-    dataDir: string;
-} | {
-    ok: false;
-    reason: string;
-};
-/** The acceptance gates discovery applies AFTER `CollectionSchemaZ` parses,
- *  before a schema becomes a live collection:
- *
- *  - the `primaryKey` must be a declared field flagged `primary: true` —
- *    without the flag CollectionView renders the field editable, and a
- *    rename is silently pinned back to the URL itemId on save, so the user's
- *    edit is dropped with no error;
- *  - a `feed` schema must declare an `ingest` block (else it's a dead,
- *    non-refreshable card);
- *  - `dataPath` must resolve INSIDE the workspace.
- *
- *  Exported so `manageCollection`'s `putSchema` can run the SAME gates before
- *  it reports success — a schema that passes `CollectionSchemaZ` but fails one
- *  of these would otherwise write cleanly yet be skipped on the next discovery,
- *  hiding the collection (the exact failure that tool exists to prevent). */
-export declare function acceptParsedSchema(schema: CollectionSchema, opts: {
-    source: CollectionSource;
-    workspaceRoot: string;
-}): SchemaAcceptance;
-export interface DiscoveryOptions {
-    /** Override the workspace root for project-scope skill discovery.
-     *  Default: the live `workspacePath`. Tests point this at a
-     *  `mkdtempSync` tree so they don't touch the user's real
-     *  `~/mulmoclaude/`. Mirrors the pattern in
-     *  `server/workspace/skills/catalog.ts#CatalogOptions`. */
-    workspaceRoot?: string;
-    /** Override `~/.claude/skills/` for tests. Production callers
-     *  leave this unset. Without an override, even a test-scoped
-     *  workspaceRoot still scans the real user home — which can leak
-     *  unrelated skills into the result. */
-    userSkillsDir?: string;
-}
-/** Discover every schema-driven collection available to this
- *  workspace. Project-scope collections override user-scope on slug
- *  collision. The `workspaceRoot` override also flows into each
- *  collection's dataDir resolution so a tmpdir-scoped test gets
- *  dataDirs under the same tmpdir (Codex P1 review on PR #1489 —
- *  previously dataDir was always rooted at the live workspacePath
- *  regardless of override). */
-export declare function discoverCollections(opts?: DiscoveryOptions): Promise<LoadedCollection[]>;
-/** Load one collection by slug. Returns null if the slug is invalid,
- *  no matching skill exists, or the schema is malformed. */
-export declare function loadCollection(slug: string, opts?: DiscoveryOptions): Promise<LoadedCollection | null>;
-export declare function toSummary(collection: LoadedCollection): CollectionSummary;
-export declare function toDetail(collection: LoadedCollection): CollectionDetail;
-//# sourceMappingURL=discovery.d.ts.map

package/dist/server/discovery.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../src/server/discovery.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,gBAAgB,EAA8B,gBAAgB,EAAE,gBAAgB,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA+YhK,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmR1B,CAAC;AAmBL;qEACqE;AACrE,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7F;;;;;;;;;;;;;;6EAc6E;AAC7E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,EAAE;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAAG,gBAAgB,CAQxI;AA+ED,MAAM,WAAW,gBAAgB;IAC/B;;;;+DAI2D;IAC3D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;4CAGwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;+BAM+B;AAC/B,wBAAsB,mBAAmB,CAAC,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgBlG;AAED;4DAC4D;AAC5D,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAchH;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,gBAAgB,GAAG,iBAAiB,CAEzE;AAED,wBAAgB,QAAQ,CAAC,UAAU,EAAE,gBAAgB,GAAG,gBAAgB,CAEvE"}

package/dist/server/host.d.ts

@@ -1,78 +0,0 @@
-/** Logger shape the engine logs through — matches the host `Logger`
- *  (prefix, message, optional structured data). */
-export interface CollectionLogger {
-    error: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    warn: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    info: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-    debug: (prefix: string, message: string, data?: Record<string, unknown>) => void;
-}
-export interface CollectionHost {
-    /** Absolute path to the host workspace root (e.g. `~/mulmoclaude`). The
-     *  default root for every path/containment check that isn't given an
-     *  explicit override. */
-    workspaceRoot: string;
-    /** Host logger; the engine logs under the `"collections"` prefix. */
-    log: CollectionLogger;
-    /** Host workspace layout — supplied as the host's own path helpers so the
-     *  package owns no layout literals and works against a test/alt root. */
-    paths: {
-        /** Absolute user-scope skills dir (host-specific, e.g. `~/.claude/skills`). */
-        userSkillsDir: string;
-        /** Absolute project-scope skills dir for a workspace (`<root>/.claude/skills`). */
-        projectSkillsDir: (workspaceRoot: string) => string;
-        /** Absolute feeds-registry root for a workspace (`<root>/data/feeds`). */
-        feedsRoot: (workspaceRoot: string) => string;
-        /** Absolute project-skills *staging* dir for a workspace (`<root>/data/skills`). */
-        skillsStagingDir: (workspaceRoot: string) => string;
-        /** Workspace-relative archive dir (a removed collection's files move here). */
-        archiveDir: string;
-    };
-    /** True for a preset-skill slug (host-owned naming convention). */
-    isPresetSlug: (slug: string) => boolean;
-}
-/** A collection's records changed on disk. Carries the `slug` so the host can
- *  publish on a per-collection channel; `ids` lists the affected record ids
- *  when known (a consumer may ignore them and refetch the whole collection),
- *  and `op` is advisory. Deliberately carries NO record bodies — this is a
- *  "refetch" ping, not a data feed, so it stays cheap and leaks nothing when a
- *  host relays it into an opaque-origin custom-view iframe. */
-export interface CollectionChangePayload {
-    slug: string;
-    ids?: string[];
-    op?: "upsert" | "delete";
-}
-type CollectionChangePublisher = (payload: CollectionChangePayload) => void;
-/** Wire the engine to a host. Call once at server startup, before any
- *  collection storage operation. Re-binding to a *different* host throws —
- *  silently redirecting later filesystem operations to another workspace
- *  would be a bug, not a feature. Re-calling with the same host is a no-op. */
-export declare function configureCollectionHost(host: CollectionHost): void;
-/** Wire a publisher that broadcasts record-change events; the host bridges it
- *  to its pubsub. Kept SEPARATE from `configureCollectionHost` because the
- *  host's pubsub instance isn't ready at host-binding time (the binding is set
- *  at the top of server startup, the pubsub later). Optional: left unset, every
- *  write is silent — the default for tests and for a host that doesn't want
- *  live view updates. Pass `null` to detach (test teardown). */
-export declare function setCollectionChangePublisher(publish: CollectionChangePublisher | null): void;
-/** Broadcast a record-change event if a publisher is wired (no-op otherwise).
- *  Called from the write path (`writeItem`/`deleteItem`). The wired publisher is
- *  expected to be fire-and-forget (it wraps its own pubsub call in try/catch),
- *  so this stays a thin pass-through and never throws into the write. */
-export declare function publishCollectionChange(payload: CollectionChangePayload): void;
-/** The configured workspace root. Throws if the host never configured one. */
-export declare function getWorkspaceRoot(): string;
-export declare function userSkillsDir(): string;
-export declare function projectSkillsDir(workspaceRoot: string): string;
-export declare function feedsRoot(workspaceRoot: string): string;
-export declare function skillsStagingDir(workspaceRoot: string): string;
-export declare function archiveDir(): string;
-export declare function isPresetSlug(slug: string): boolean;
-/** Logger proxy so engine modules can `import { log }` and use it exactly like
- *  the host logger — each call forwards to the live host binding. Logging is
- *  non-critical, so calls before the host configures a binding (e.g. unit tests
- *  that exercise pure logic) are dropped rather than throwing — unlike
- *  `getWorkspaceRoot()`, which fails loudly because the engine cannot operate
- *  without a workspace root. */
-export declare const log: CollectionLogger;
-export {};
-//# sourceMappingURL=host.d.ts.map

package/dist/server/host.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/server/host.ts"],"names":[],"mappings":"AAUA;mDACmD;AACnD,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACjF,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAChF,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAChF,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CAClF;AAED,MAAM,WAAW,cAAc;IAC7B;;6BAEyB;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,GAAG,EAAE,gBAAgB,CAAC;IACtB;6EACyE;IACzE,KAAK,EAAE;QACL,+EAA+E;QAC/E,aAAa,EAAE,MAAM,CAAC;QACtB,mFAAmF;QACnF,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,MAAM,CAAC;QACpD,0EAA0E;QAC1E,SAAS,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,MAAM,CAAC;QAC7C,oFAAoF;QACpF,gBAAgB,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,MAAM,CAAC;QACpD,+EAA+E;QAC/E,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,mEAAmE;IACnE,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CACzC;AAED;;;;;+DAK+D;AAC/D,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;CAC1B;AAED,KAAK,yBAAyB,GAAG,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAC;AAK5E;;;+EAG+E;AAC/E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAKlE;AAED;;;;;gEAKgE;AAChE,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI,GAAG,IAAI,CAE5F;AAED;;;yEAGyE;AACzE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAE9E;AASD,8EAA8E;AAC9E,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAKD,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AACD,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE9D;AACD,wBAAgB,SAAS,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEvD;AACD,wBAAgB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAE9D;AACD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AACD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;gCAKgC;AAChC,eAAO,MAAM,GAAG,EAAE,gBAKjB,CAAC"}

package/dist/server/index.d.ts

@@ -1,12 +0,0 @@
-export { configureCollectionHost, getWorkspaceRoot, log, setCollectionChangePublisher, publishCollectionChange, type CollectionHost, type CollectionLogger, type CollectionChangePayload, } from "./host";
-export type { LoadedCollection } from "./discoveredCollection";
-export * from "./paths";
-export * from "./templatePath";
-export * from "./io";
-export * from "./validate";
-export * from "./discovery";
-export * from "./derive";
-export * from "./spawn";
-export * from "./delete";
-export * from "./views";
-//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,GAAG,EACH,4BAA4B,EAC5B,uBAAuB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,QAAQ,CAAC;AAChB,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,MAAM,CAAC;AACrB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC"}

package/dist/server/io.d.ts

@@ -1,115 +0,0 @@
-import type { CollectionItem, CollectionSchema } from "../core/schema";
-import type { LoadedCollection } from "./discoveredCollection";
-export interface IoOptions {
-    /** Override the workspace root for containment checks. Default:
-     *  the live `workspacePath`. Tests point this at a `mkdtempSync`
-     *  tree so the realpath-based escape detection can be exercised
-     *  without touching `~/mulmoclaude/`. Same pattern as
-     *  `server/workspace/skills/catalog.ts#CatalogOptions`. */
-    workspaceRoot?: string;
-    /** Collection slug this write/delete belongs to. When provided, a
-     *  successful write/delete publishes a record-change event (see
-     *  `publishCollectionChange`) so live views refetch. `writeItem` has no
-     *  slug of its own (it's keyed by `dataDir`), so callers thread it through;
-     *  omitting it just means no event is published (internal / test writes). */
-    slug?: string;
-}
-/** Read every record under `dataDir`. Returns [] if the dir doesn't
- *  exist yet (legitimate first-use state). Malformed JSON files and
- *  symlinked records are skipped (the latter is a file-disclosure
- *  defense — see `isRegularFile`). Re-validates the realpath
- *  containment to defend against a symlinked data dir appearing
- *  between discovery and use. */
-export declare function listItems(dataDir: string, opts?: IoOptions): Promise<CollectionItem[]>;
-/** Read one record by id. Returns null when the file is missing,
- *  when the resolved path escapes the workspace via a symlink, or
- *  when the record file itself is a symlink (file-disclosure
- *  defense — see `isRegularFile`). */
-export declare function readItem(dataDir: string, itemId: string, opts?: IoOptions): Promise<CollectionItem | null>;
-export interface WriteItemOptions extends IoOptions {
-    /** When true (POST/create), refuse to overwrite an existing file
-     *  and return `kind: "conflict"`. Update flow (PUT) leaves it false. */
-    refuseOverwrite?: boolean;
-}
-export type WriteItemResult = {
-    kind: "ok";
-    itemId: string;
-    item: CollectionItem;
-} | {
-    kind: "invalid-id";
-    itemId: string;
-} | {
-    kind: "conflict";
-    itemId: string;
-} | {
-    kind: "path-escape";
-    itemId: string;
-};
-/** Write a record. Ensures the directory exists, validates the id,
- *  re-checks symlink containment after mkdir, and writes atomically.
- *
- *  Create path (`refuseOverwrite: true`) uses an O_EXCL `wx` open
- *  rather than `stat` + `writeFileAtomic` to close a check-then-write
- *  race: two concurrent POSTs would otherwise both pass the existence
- *  check and one would silently overwrite the other. The trade-off
- *  is that the create path is not crash-atomic (a partial file could
- *  remain if the process dies mid-write); acceptable here because
- *  records are small JSON blobs and the next read either parses or
- *  is skipped via the "malformed JSON" branch in `listItems`.
- *
- *  Update path (`refuseOverwrite: false`) uses `writeFileAtomic` so
- *  PUT remains crash-atomic. No race there — the URL pins the id. */
-export declare function writeItem(dataDir: string, itemId: string, item: CollectionItem, opts?: WriteItemOptions): Promise<WriteItemResult>;
-export type DeleteItemResult = {
-    kind: "ok";
-    itemId: string;
-} | {
-    kind: "invalid-id";
-    itemId: string;
-} | {
-    kind: "not-found";
-    itemId: string;
-} | {
-    kind: "path-escape";
-    itemId: string;
-};
-export declare function deleteItem(dataDir: string, itemId: string, opts?: IoOptions): Promise<DeleteItemResult>;
-/** Generate a short random hex id. Used by POST when the form doesn't
- *  carry a primary-key value (UI shortcut — Claude normally derives a
- *  semantic id from the record's name). */
-export declare function generateItemId(): string;
-/** Read a collection's custom-view HTML, path-safely. `viewFile` is a
- *  schema-validated `views/*.html` path, resolved with realpath containment.
- *  Returns the HTML, or null when the path is unsafe or the file is missing.
- *
- *  The base dir is source-aware: a **project** collection authors views in the
- *  `data/skills/<slug>/` staging dir (custom-view HTML is staging-only — NOT
- *  mirrored to `.claude/skills`, because rendering is host-side; see
- *  plans/feat-collections-custom-views.md), whereas a **user** / **feed**
- *  collection is authored directly in its own discovered `skillDir`. Reading
- *  relative to the wrong tree would 404 a perfectly valid view. */
-export declare function readCustomViewHtml(collection: Pick<LoadedCollection, "slug" | "source" | "skillDir">, viewFile: string, opts?: IoOptions): Promise<string | null>;
-/** The item id a CREATE should use for `schema`, or null when the
- *  caller should generate one. A singleton collection pins every
- *  create to its fixed `schema.singleton` id, so the "at most one
- *  record" contract is enforced server-side (a second create targets
- *  the same file and hits `writeItem`'s refuseOverwrite conflict) —
- *  not only in the UI. Otherwise the record's own primaryKey value
- *  wins, falling back to a generated id (null = "generate"). */
-export declare function resolveCreateItemId(schema: CollectionSchema, record: CollectionItem): string | null;
-/** Read an action's template file from `skillDir`, path-safely. Returns
- *  the file contents, or null when the path escapes the skill dir, the
- *  resolved target isn't a regular file, or the read fails. */
-export declare function readSkillTemplate(skillDir: string, templateRelPath: string): Promise<string | null>;
-/** Build the seed prompt for a `kind: "chat"` action: a security-
- *  boundary instruction + the record as a sanitized JSON data block +
- *  the template text verbatim. Pure + exported for tests. Domain-free —
- *  the template (skill-owned) carries every specific instruction; the
- *  host only injects the record's own data. */
-export declare function buildActionSeedPrompt(record: CollectionItem, templateText: string): string;
-/** Build the seed prompt for a collection-level `kind: "chat"` action: a
- *  security-boundary instruction + a compact progress summary of every
- *  record (see `progressSummary`) + the template verbatim. Pure +
- *  exported for tests. Domain-free — the template carries the specifics. */
-export declare function buildCollectionActionSeedPrompt(items: CollectionItem[], schema: CollectionSchema, templateText: string): string;
-//# sourceMappingURL=io.d.ts.map

package/dist/server/io.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"io.d.ts","sourceRoot":"","sources":["../../src/server/io.ts"],"names":[],"mappings":"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"}

package/dist/server/paths.d.ts

@@ -1,53 +0,0 @@
-export declare const SCHEMA_FILE = "schema.json";
-/** Sanitise a user-supplied slug into a safe directory-name leaf.
- *  Returns null for anything that fails the slug whitelist OR isn't a
- *  basename (i.e. survives `path.basename` round-trip unchanged).
- *  The basename round-trip is the pattern CodeQL recognises as a
- *  `js/path-injection` sanitiser. */
-export declare function safeSlugName(slug: string): string | null;
-/** Sanitise a user-supplied record id into a safe filename stem. Like
- *  `safeSlugName` but tolerates interior dots (so natural keys work),
- *  while still rejecting any `..` substring, path separators, and
- *  leading/trailing dots. The `path.basename` round-trip is the same
- *  `js/path-injection` sanitiser CodeQL recognises on `safeSlugName`. */
-export declare function safeRecordId(recordId: string): string | null;
-/** True iff the realpath'd closest existing ancestor of `absPath`
- *  resolves under `rootPath`'s realpath. Pure helper, takes both
- *  paths explicitly so tests can drive it against a `mkdtempSync`
- *  root without touching the user's workspace. Defends against the
- *  data dir or any ancestor being a symlink to a directory outside
- *  the workspace — lexical-only checks (`path.resolve` + prefix
- *  match) would miss this case, which is the class of bug the rest
- *  of this codebase uses realpath-based containment to avoid (see
- *  `server/utils/files/safe.ts#resolveWithinRoot`). */
-export declare function isContainedInRoot(absPath: string, rootPath: string): boolean;
-/** Workspace-bound convenience over `isContainedInRoot`. Production
- *  callers use this; the tests exercise the pure helper. */
-export declare function isContainedInWorkspace(absPath: string): boolean;
-/** Resolve a schema-declared dataPath against `rootPath` (default:
- *  the live workspace), refusing anything that escapes — absolute
- *  paths, `..`-segments, empty string, or symlinks pointing outside
- *  the root. Returns the absolute path on success, null on refusal.
- *  Does NOT require the directory to exist; the caller may create it
- *  on first write. The realpath containment check covers the symlink
- *  case at discovery time; io operations re-check before each write
- *  to defend against symlinks introduced between discovery and use.
- *
- *  `rootPath` exists as an optional override so a test (or a tool
- *  driving discovery against a `mkdtempSync` tree) gets a dataDir
- *  rooted at the same place it asked to scan, not the real workspace.
- *  Without this, `discoverApps({ workspaceRoot: tmpdir })` would
- *  discover skills in tmpdir but resolve every app's dataDir against
- *  `~/mulmoclaude/`, breaking isolation. */
-export declare function resolveDataDir(dataPath: string, rootPath?: string): string | null;
-/** Compose the absolute path to a single record file. Both arguments
- *  must have been passed through `safeSlugName` / `resolveDataDir`
- *  before reaching here so the join can't escape. */
-export declare function itemFilePath(dataDir: string, itemId: string): string;
-/** Resolve an action's skill-relative `template` path against
- *  `skillDir`, refusing escapes — absolute paths, `..`-segments, or a
- *  symlink pointing outside the skill dir. Mirrors `resolveDataDir`;
- *  the realpath containment is the hard guarantee. Returns the
- *  absolute path on success, null on refusal. */
-export declare function resolveTemplatePath(skillDir: string, templateRelPath: string): string | null;
-//# sourceMappingURL=paths.d.ts.map

package/dist/server/paths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/server/paths.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,gBAAgB,CAAC;AAQzC;;;;qCAIqC;AACrC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMxD;AAaD;;;;yEAIyE;AACzE,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO5D;AAwBD;;;;;;;;uDAQuD;AACvD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAW5E;AAED;4DAC4D;AAC5D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;;4CAc4C;AAC5C,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAA2B,GAAG,MAAM,GAAG,IAAI,CAQrG;AAED;;qDAEqD;AACrD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;;;iDAIiD;AACjD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ5F"}

package/dist/server/spawn.d.ts

@@ -1,56 +0,0 @@
-import { type IoOptions } from "./io";
-import type { CollectionEvery, CollectionItem, CollectionSchema, CollectionSpawnEvery } from "../core/schema";
-/** A timezone-free calendar date. `m` is 1-12. */
-export interface CivilDate {
-    y: number;
-    m: number;
-    d: number;
-}
-/** Days in `month` (1-12) of `year`, leap-year-aware. `new Date(y, m, 0)`
- *  is day 0 of the *next* month = the last day of `month`; `.getDate()`
- *  reads the civil day regardless of timezone. */
-export declare function daysInMonth(year: number, month: number): number;
-/** Parse a `YYYY-MM-DD` string into a CivilDate, or null when the value
- *  isn't a well-formed in-range calendar date. */
-export declare function parseCivil(raw: unknown): CivilDate | null;
-/** `YYYY-MM-DD` for storage in a `date` field. */
-export declare function formatCivil(date: CivilDate): string;
-/** Advance a civil date by one `every` step. Month/year units preserve
- *  the rule's day-of-month anchor, clamped to the target month's length
- *  (no drift); day/week units do civil day arithmetic. */
-export declare function advanceTriggerDate(source: CivilDate, every: CollectionEvery): CivilDate;
-/** True iff `now`'s civil date (local timezone) has reached the fire date
- *  for `triggerRaw` — i.e. the trigger date minus `leadDays` (so a 10-day
- *  lead fires 10 days early). Returns null when `triggerRaw` isn't a
- *  parseable date — callers treat that as "don't fire" and warn. */
-export declare function isTriggerDue(triggerRaw: unknown, now: Date, leadDays?: number): boolean | null;
-/** Deterministic successor id: `<stem>-<YYYYMMDD>`, where `<stem>` is the
- *  source id with a trailing `-YYYYMMDD` stripped if present. So a chain
- *  shares one stem and each instance is dated:
- *    `rent`           → `rent-20260610`
- *    `rent-20260610`  → `rent-20260710`
- *  Slug-safe (alphanumeric + hyphen) and a pure function of the inputs,
- *  which is what makes create-if-absent idempotent. */
-export declare function successorId(sourceId: string, next: CivilDate): string;
-/** Resolve the literal `every` that applies to `sourceItem`. Literal-arm
- *  `spawn.every` passes through unchanged. Field-driven `spawn.every` reads
- *  `sourceItem[fromField]` and looks it up in `map`; an empty field or a
- *  value with no map entry yields null (caller skips + logs — see plan §5).
- *  Discovery rejects a map that doesn't cover the enum's values, so null
- *  here means a record that predates a map/enum edit. */
-export declare function resolveEvery(every: CollectionSpawnEvery, sourceItem: CollectionItem): CollectionEvery | null;
-export interface ComputedSuccessor {
-    id: string;
-    record: CollectionItem;
-}
-/** Build the successor record purely from (schema, source record, source
- *  id). Returns null when the schema has no spawn/triggerField or the
- *  source's trigger date is unparseable. */
-export declare function computeSuccessor(schema: CollectionSchema, sourceItem: CollectionItem, sourceId: string): ComputedSuccessor | null;
-/** Idempotently create the successor for `sourceItem` when it matches the
- *  spawn predicate. No-op when the schema declares no spawn, the
- *  predicate doesn't match, the trigger date is unparseable, or the
- *  successor already exists (create-if-absent). Never overwrites an
- *  existing successor — protects any edits the user made to it. */
-export declare function maybeSpawnSuccessor(slug: string, schema: CollectionSchema, dataDir: string, sourceItem: CollectionItem, sourceId: string, ioOpts?: IoOptions): Promise<void>;
-//# sourceMappingURL=spawn.d.ts.map

package/dist/server/spawn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../src/server/spawn.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,oBAAoB,EAAkB,MAAM,gBAAgB,CAAC;AAE9H,kDAAkD;AAClD,MAAM,WAAW,SAAS;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAYD;;kDAEkD;AAClD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;kDACkD;AAClD,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAUzD;AAED,kDAAkD;AAClD,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAEnD;AAeD;;0DAE0D;AAC1D,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,CAYvF;AAED;;;oEAGoE;AACpE,wBAAgB,YAAY,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,SAAI,GAAG,OAAO,GAAG,IAAI,CAMzF;AAID;;;;;;uDAMuD;AACvD,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAGrE;AAiBD;;;;;yDAKyD;AACzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,GAAG,eAAe,GAAG,IAAI,CAK5G;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,cAAc,CAAC;CACxB;AAED;;4CAE4C;AAC5C,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAiBjI;AAoBD;;;;mEAImE;AACnE,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,cAAc,EAC1B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,SAAc,GACrB,OAAO,CAAC,IAAI,CAAC,CAiCf"}

package/dist/server/templatePath.d.ts

@@ -1,26 +0,0 @@
-/**
- * A safe skill-relative path: non-empty, no backslash, not absolute,
- * and every `/`-separated segment is a plain `[A-Za-z0-9._-]+` token
- * that isn't `.` / `..` (no traversal). Multi-segment (nested) paths
- * are allowed. The reader's realpath containment is the hard
- * guarantee; this fails a bad path fast.
- */
-export declare function isSafeTemplatePath(value: string): boolean;
-/**
- * An action `template` value: a safe path that lives under the skill's
- * `templates/` subdir. This is the canonical contract — the schema
- * validator rejects anything else up front, and the bridge mirrors
- * exactly these. Nested paths (`templates/mail/welcome.md`) and any
- * extension are allowed as long as the path is otherwise safe.
- */
-export declare function isSafeActionTemplatePath(value: string): boolean;
-/**
- * A custom-view `file` value: a safe path under the skill's `views/`
- * subdir that ends in `.html`. Custom views are LLM-authored HTML the
- * host renders in a sandboxed iframe; constraining them to `views/*.html`
- * keeps the data folder and the schema/template files off-limits to the
- * view-file reader. Same per-segment safety as templates; the reader's
- * realpath containment is the hard guarantee.
- */
-export declare function isSafeCustomViewPath(value: string): boolean;
-//# sourceMappingURL=templatePath.d.ts.map

package/dist/server/templatePath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"templatePath.d.ts","sourceRoot":"","sources":["../../src/server/templatePath.ts"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAGzD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/D;AAKD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE3D"}

package/dist/server/util.d.ts

@@ -1,4 +0,0 @@
-/** Human-readable message from an unknown thrown value. */
-export declare function errorMessage(err: unknown): string;
-export declare const ONE_DAY_MS: number;
-//# sourceMappingURL=util.d.ts.map

package/dist/server/util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/server/util.ts"],"names":[],"mappings":"AAGA,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEjD;AAED,eAAO,MAAM,UAAU,QAAsB,CAAC"}

package/dist/server/validate.d.ts

@@ -1,20 +0,0 @@
-import type { LoadedCollection } from "./discoveredCollection";
-import type { CollectionItem, CollectionSchema } from "../core/schema";
-export interface RecordIssue {
-    /** Record filename, e.g. `lesson-003.json`. */
-    file: string;
-    /** Human-readable problem, written to be actionable by the LLM. */
-    problem: string;
-}
-export declare const COMPUTED_TYPES: ReadonlySet<string>;
-export declare function validateCollectionRecords(collection: LoadedCollection, opts?: {
-    workspaceRoot?: string;
-}): Promise<RecordIssue[]>;
-/** First schema problem on an in-memory record (primaryKey↔id mismatch,
- *  missing required, bad enum value), or null when it's fine. One issue
- *  per record keeps the report short and the fix obvious. Pure +
- *  exported so write paths (manageCollection putItems) can gate on the
- *  SAME rules the post-hoc file scan reports — `itemId` is the id the
- *  record is (or would be) stored under. */
-export declare function validateRecordObject(record: CollectionItem, itemId: string, schema: CollectionSchema): string | null;
-//# sourceMappingURL=validate.d.ts.map

package/dist/server/validate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/server/validate.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvE,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAA2C,CAAC;AAsB3F,wBAAsB,yBAAyB,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAW3I;AAoCD;;;;;4CAK4C;AAC5C,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAepH"}