@lapis-notes/api 0.1.4 → 0.2.0

package/dist/native-participant-protocol.d.ts

@@ -0,0 +1,67 @@
+import type { TurnInput, TurnOptions } from "./native-turn-protocol";
+import type { QueueSelection } from "./native-queue-protocol";
+export declare const PARTICIPANT_PROFILE_LIMIT: 16;
+export declare const PARTICIPANT_REQUEST_LIMIT: 2097152;
+export declare const PARTICIPANT_RECORD_LIMIT: 8388608;
+export type ParticipantProfile = {
+    target_id: string;
+    selection: QueueSelection;
+    options: TurnOptions;
+};
+export type ParticipantMessageInput = {
+    acceptance_id: string;
+    user: unknown;
+    dispatch: unknown;
+    turns: Array<TurnInput>;
+    profiles?: Array<ParticipantProfile>;
+};
+export type ParticipantState = "pending" | "started" | "completed" | "rejected" | "unknown" | "not_sent" | "cancelled";
+export type ParticipantDelivery = {
+    delivery_id: string;
+    request_id: string;
+    agent_binding_id: string;
+    session_id: string;
+    state: ParticipantState;
+    outcome_published: boolean;
+};
+export type ParticipantMessage = {
+    schema_version: number;
+    vault_id: string;
+    acceptance_id: string;
+    conversation_id: string;
+    input: ParticipantMessageInput;
+    deliveries: Array<ParticipantDelivery>;
+    recovered: boolean;
+};
+export type ParticipantCommand = {
+    kind: "profiles";
+} | {
+    kind: "for_turn";
+    request_id: string;
+} | {
+    kind: "accept";
+    input: ParticipantMessageInput;
+} | {
+    kind: "read";
+    acceptance_id: string;
+} | {
+    kind: "stop";
+    acceptance_id: string;
+} | {
+    kind: "cancel";
+    acceptance_id: string;
+    request_id: string;
+};
+export type ParticipantValue = {
+    kind: "profiles";
+    profiles: Array<ParticipantProfile>;
+} | {
+    kind: "message";
+    message: ParticipantMessage | null;
+} | {
+    kind: "stop_requested";
+    accepted: boolean;
+} | {
+    kind: "cancel_requested";
+    accepted: boolean;
+};

package/dist/native-participant-protocol.js

@@ -0,0 +1,3 @@
+export const PARTICIPANT_PROFILE_LIMIT = 16;
+export const PARTICIPANT_REQUEST_LIMIT = 2097152;
+export const PARTICIPANT_RECORD_LIMIT = 8388608;

package/dist/native-queue-protocol.d.ts

@@ -0,0 +1,73 @@
+export declare const QUEUE_REQUEST_LIMIT: 1048576;
+export declare const QUEUE_RECORD_LIMIT: 8388608;
+export type QueueRecipient = {
+    id: string;
+    label: string;
+    token: string;
+};
+export type QueueModel = {
+    provider: string;
+    model: string;
+};
+export type QueueAgent = "codex" | "cursor" | "opencode" | "local";
+export type QueueThinking = "default" | "off" | "low" | "medium" | "high";
+export type QueueCaptureTarget = {
+    id: string;
+    agent: QueueAgent;
+    model?: QueueModel;
+    thinking?: QueueThinking;
+    executionMode?: string;
+};
+export type QueueSelection = {
+    recipient: QueueRecipient;
+    target: QueueCaptureTarget;
+    thinking?: QueueThinking;
+};
+export type QueueAccept = {
+    acceptance_id: string;
+    conversation_id: string;
+    after_request_id: string;
+    scope_dir: string;
+    target_id: string;
+    capture: unknown;
+};
+export type QueuePhase = "pending" | "started" | "completed" | "cancelled" | "rejected" | "unknown";
+export type QueueEntry = {
+    input: QueueAccept;
+    request_id: string;
+    phase: QueuePhase;
+    receipt: unknown | null;
+    receipt_published: boolean;
+};
+export type QueueRecord = {
+    schema_version: number;
+    vault_id: string;
+    conversation_id: string;
+    scope_dir: string;
+    head_request_id: string;
+    paused: boolean;
+    barrier: string | null;
+    entries: Array<QueueEntry>;
+};
+export type QueueCommand = {
+    kind: "accept";
+    input: QueueAccept;
+} | {
+    kind: "read";
+    conversation_id: string;
+} | {
+    kind: "stop";
+    conversation_id: string;
+} | {
+    kind: "cancel";
+    conversation_id: string;
+    acceptance_id: string;
+} | {
+    kind: "resume";
+    conversation_id: string;
+    after_request_id: string;
+};
+export type QueueValue = {
+    kind: "queue";
+    queue: QueueRecord | null;
+};

package/dist/native-queue-protocol.js

@@ -0,0 +1,3 @@
+// Generated by pnpm protocol:generate. Do not edit.
+export const QUEUE_REQUEST_LIMIT = 1048576;
+export const QUEUE_RECORD_LIMIT = 8388608;

package/dist/native-tasks-protocol.d.ts

@@ -0,0 +1,264 @@
+export type TextSnapshot = {
+    path: string;
+    text: string;
+    version: string;
+};
+export type NativeTaskStart = {
+    kind: "anytime";
+} | {
+    kind: "someday";
+} | {
+    kind: "date";
+    date: string;
+};
+export type NativeTaskPlanAt = "anytime" | "morning" | "afternoon" | "evening" | "time";
+export type NativeTaskPlan = {
+    date: string;
+    at: NativeTaskPlanAt;
+    time?: string;
+    duration?: string;
+    durationMinutes?: number;
+};
+export type NativeTaskTracking = {
+    type: "boolean";
+} | {
+    type: "count";
+    unit: string;
+    target?: number;
+} | {
+    type: "duration";
+    target?: string;
+} | {
+    type: "number";
+    unit: string;
+    target?: number;
+};
+export type NativeTaskRepeatAnchor = "schedule" | "completion";
+export type NativeTaskRepeatMissed = "carry" | "skip";
+export type NativeTaskPauseRange = {
+    start: string;
+    end: string;
+};
+export type NativeTaskRepeat = {
+    start?: string;
+    rrule: string;
+    anchor: NativeTaskRepeatAnchor;
+    missed: NativeTaskRepeatMissed;
+    rdate?: Array<string>;
+    exdate?: Array<string>;
+    resetChecklist?: boolean;
+    paused?: boolean;
+    pausedSince?: string;
+    pauseRanges?: Array<NativeTaskPauseRange>;
+    lastCompletedAt?: string;
+    completionCount?: number;
+};
+export type NativeTaskMutation = {
+    type: "checklist";
+    position: number;
+    expectedText: string;
+    checked: boolean;
+} | {
+    type: "plan";
+    plan: NativeTaskPlan | null;
+    at: string;
+} | {
+    type: "start";
+    start: NativeTaskStart;
+    at: string;
+} | {
+    type: "deadline";
+    deadline: string | null;
+    at: string;
+} | {
+    type: "inbox";
+    inbox: boolean;
+    at: string;
+} | {
+    type: "repeat";
+    repeat: NativeTaskRepeat | null;
+    at: string;
+} | {
+    type: "tracking";
+    tracking: NativeTaskTracking | null;
+    at: string;
+} | {
+    type: "pause";
+    at: string;
+    localDate: string | null;
+} | {
+    type: "resume";
+    at: string;
+    localDate: string | null;
+} | {
+    type: "cancel";
+    at: string;
+} | {
+    type: "reopen";
+    at: string;
+};
+export type NativeTaskLifecycleAction = {
+    type: "complete";
+    at: string;
+    localDate: string;
+    trackedValue: number | null;
+} | {
+    type: "skip";
+    at: string;
+    localDate: string;
+};
+export type NativeTaskLifecycleRequest = {
+    request_id: string;
+    path: string;
+    expected_version: string;
+    action: NativeTaskLifecycleAction;
+};
+export type NativeTaskCompletion = {
+    type: "boolean";
+} | {
+    type: "count";
+    value: number;
+    unit: string;
+} | {
+    type: "duration";
+    durationMinutes: number;
+} | {
+    type: "number";
+    value: number;
+    unit: string;
+};
+export type NativeTaskDayParts = {
+    afternoonStartsAt: string;
+    eveningStartsAt: string;
+};
+export type NativeTaskDailySettings = {
+    folder: string;
+    date_format: string;
+};
+export type NativeTaskDailyFormat = {
+    locale: string;
+    firstDay: number;
+    minimalDays: number;
+};
+export type NativeTaskProvider = {
+    kind: "default";
+} | {
+    kind: "unavailable";
+    message: string;
+};
+export type NativeTaskConfiguration = {
+    day_parts: NativeTaskDayParts;
+    daily: NativeTaskDailySettings;
+    format: NativeTaskDailyFormat;
+    provider: NativeTaskProvider;
+};
+export type NativeTaskDisposition = "retryable" | "divergent" | "completed";
+export type NativeTaskKnownFailure = {
+    code: string;
+    message: string;
+};
+export type NativeTaskOperation = {
+    request: NativeTaskLifecycleRequest;
+    disposition: NativeTaskDisposition;
+    original: TextSnapshot;
+    task_replacement: string;
+    daily: TextSnapshot | null;
+    daily_replacement: string | null;
+    last_failure: NativeTaskKnownFailure | null;
+};
+export type NativeTaskFailure = {
+    name: string;
+    code: string | null;
+    message: string;
+    parts: Array<string> | null;
+    request_id: string | null;
+    uncertain: boolean;
+    operation: NativeTaskOperation | null;
+};
+export type NativeTaskTrackedFailure = {
+    path: string;
+    message: string;
+    daily_path: string | null;
+    daily_version: string | null;
+};
+export type NativeTaskTrackedStatus = {
+    date: string;
+    attempted: number;
+    materialized: number;
+    changed: number;
+    failures: Array<NativeTaskTrackedFailure>;
+    omitted_failures: number;
+};
+export type NativeTasksStatus = {
+    enabled: boolean;
+    configuration: NativeTaskConfiguration | null;
+    tracked: NativeTaskTrackedStatus | null;
+};
+export type NativeTaskOutcome = "completed" | "pending";
+export type NativeTaskTrackingKind = "boolean" | "count" | "duration" | "number";
+export type NativeTaskDayPart = "anytime" | "morning" | "afternoon" | "evening";
+export type NativeTaskObservation = {
+    observationId: string;
+    taskId: string;
+    taskPath: string;
+    dailyDocumentPath: string;
+    occurrenceDate: string;
+    outcome: NativeTaskOutcome;
+    trackingKind: NativeTaskTrackingKind;
+    value?: number;
+    unit?: string;
+    durationMinutes?: number;
+    sourceStart: number;
+    sourceEnd: number;
+    projectionVersion: number;
+    checked: boolean;
+    title: string;
+    href: string;
+    dayPart: NativeTaskDayPart;
+    source: string;
+};
+export type NativeTaskCommand = {
+    kind: "configure";
+    configuration: NativeTaskConfiguration;
+} | {
+    kind: "disable";
+} | {
+    kind: "status";
+} | {
+    kind: "mutate";
+    path: string;
+    expected_version: string;
+    mutation: NativeTaskMutation;
+} | {
+    kind: "submit";
+    request: NativeTaskLifecycleRequest;
+} | {
+    kind: "inspect";
+    request_id: string;
+} | {
+    kind: "retry";
+    request_id: string;
+} | {
+    kind: "occurrence";
+    path: string;
+    expected_version: string;
+    date: string;
+    completion: NativeTaskCompletion | null;
+};
+export type NativeTaskValue = {
+    kind: "status";
+    status: NativeTasksStatus;
+} | {
+    kind: "snapshot";
+    snapshot: TextSnapshot;
+} | {
+    kind: "operation";
+    operation: NativeTaskOperation | null;
+} | {
+    kind: "observation";
+    document: TextSnapshot;
+    observation: NativeTaskObservation;
+} | {
+    kind: "failure";
+    failure: NativeTaskFailure;
+};

package/dist/native-tasks-protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/native-tasks.d.ts

@@ -0,0 +1,35 @@
+import type { NativeTaskCommand, NativeTaskFailure, NativeTaskValue } from "./native-tasks-protocol";
+export type * from "./native-tasks-protocol";
+/** A bounded transport already admitted to one native vault owner. */
+export interface NativeTasks {
+    call(command: NativeTaskCommand): Promise<NativeTaskValue>;
+}
+/** Capture the existing default daily provider's Luxon formatting context. */
+export declare function nativeTaskDailyFormat(): {
+    locale: string;
+    firstDay: import("luxon").WeekdayNumbers;
+    minimalDays: import("luxon").WeekdayNumbers;
+};
+export declare class NativeTaskError extends Error {
+    readonly code: string | null;
+    readonly parts: string[] | null;
+    readonly requestId: string | null;
+    readonly uncertain: boolean;
+    readonly operation: NativeTaskFailure["operation"];
+    constructor(failure: NativeTaskFailure);
+}
+/** Observation lifetime is independent of accepted native work. */
+export declare class NativeTasksSession implements NativeTasks {
+    private readonly transport;
+    private readonly declared;
+    private pending;
+    private stopped;
+    private detachPromise?;
+    constructor(transport: NativeTasks, declared?: () => boolean);
+    get detached(): boolean;
+    call(command: NativeTaskCommand): Promise<NativeTaskValue>;
+    /** Disable is explicit policy, never a consequence of closing a window. */
+    load(): Promise<void>;
+    disable(): Promise<void>;
+    detach(): Promise<void>;
+}

package/dist/native-tasks.js

@@ -0,0 +1,79 @@
+import { DateTime, Info } from "luxon";
+/** Capture the existing default daily provider's Luxon formatting context. */
+export function nativeTaskDailyFormat() {
+    return {
+        locale: DateTime.fromISO("2000-01-01", {
+            zone: "utc",
+        }).resolvedLocaleOptions().locale,
+        firstDay: Info.getStartOfWeek(),
+        minimalDays: Info.getMinimumDaysInFirstWeek(),
+    };
+}
+export class NativeTaskError extends Error {
+    code;
+    parts;
+    requestId;
+    uncertain;
+    operation;
+    constructor(failure) {
+        super(failure.message);
+        this.name = failure.name;
+        this.code = failure.code;
+        this.parts = failure.parts;
+        this.requestId = failure.request_id;
+        this.uncertain = failure.uncertain;
+        this.operation = failure.operation;
+    }
+}
+/** Observation lifetime is independent of accepted native work. */
+export class NativeTasksSession {
+    transport;
+    declared;
+    pending = new Set();
+    stopped = false;
+    detachPromise;
+    constructor(transport, declared = () => true) {
+        this.transport = transport;
+        this.declared = declared;
+    }
+    get detached() {
+        return this.stopped;
+    }
+    call(command) {
+        if (this.stopped)
+            return Promise.reject(new Error("Native Tasks observer detached"));
+        const operation = Promise.resolve()
+            .then(() => this.transport.call(command))
+            .then((value) => {
+            if (value.kind === "failure")
+                throw new NativeTaskError(value.failure);
+            return value;
+        });
+        this.pending.add(operation);
+        void operation
+            .finally(() => this.pending.delete(operation))
+            .catch(() => undefined);
+        return operation;
+    }
+    /** Disable is explicit policy, never a consequence of closing a window. */
+    async load() {
+        await Promise.all([...this.pending]);
+        if (this.stopped)
+            return;
+        if (!this.declared()) {
+            await this.disable();
+            return;
+        }
+        const value = await this.call({ kind: "status" });
+        if (value.kind !== "status")
+            throw new Error("Invalid native Tasks status");
+    }
+    async disable() {
+        await this.call({ kind: "disable" });
+    }
+    detach() {
+        this.stopped = true;
+        this.detachPromise ??= Promise.allSettled([...this.pending]).then(() => undefined);
+        return this.detachPromise;
+    }
+}

package/dist/native-turn-protocol.d.ts

@@ -0,0 +1,81 @@
+import type { QueueSelection } from "./native-queue-protocol";
+export type TurnOptions = {
+    model: string | null;
+    effort: string | null;
+    mode: string;
+    max_duration_ms: number;
+};
+export type TurnTarget = {
+    queue_selection?: QueueSelection;
+    id: string;
+    label: string;
+    default_mode: string;
+};
+export type TurnContinuation = {
+    conversation_id: string;
+    after_request_id: string;
+};
+export type TurnInput = {
+    request_id: string;
+    target_id: string;
+    scope_dir: string;
+    prompt: string;
+    context: string | null;
+    continuation?: TurnContinuation;
+    options: TurnOptions;
+};
+export type TurnPhase = "accepted" | "running" | "completed" | "failed" | "cancelled" | "interrupted" | "unknown";
+export type TurnRecord = {
+    schema_version: number;
+    vault_id: string;
+    conversation_id: string;
+    input: TurnInput;
+    phase: TurnPhase;
+    accepted_at_ms: number;
+    updated_at_ms: number;
+    output: string | null;
+    failure_code: string | null;
+};
+export type TurnSummary = {
+    request_id: string;
+    conversation_id: string;
+    target_id: string;
+    scope_dir: string;
+    phase: TurnPhase;
+    accepted_at_ms: number;
+    updated_at_ms: number;
+    failure_code: string | null;
+};
+export type TurnCommand = {
+    kind: "targets";
+} | {
+    kind: "set_enabled";
+    enabled: boolean;
+} | {
+    kind: "submit";
+    input: TurnInput;
+} | {
+    kind: "read";
+    request_id: string;
+} | {
+    kind: "list";
+} | {
+    kind: "cancel";
+    request_id: string;
+};
+export type TurnValue = {
+    kind: "targets";
+    targets: Array<TurnTarget>;
+} | {
+    kind: "availability";
+    enabled: boolean;
+} | {
+    kind: "record";
+    record: TurnRecord | null;
+} | {
+    kind: "records";
+    records: Array<TurnSummary>;
+} | {
+    kind: "cancel_requested";
+    accepted: boolean;
+};

package/dist/native-turn-protocol.js

@@ -0,0 +1 @@
+export {};

package/dist/native-turns.d.ts

@@ -0,0 +1,29 @@
+import type { TurnCommand, TurnValue } from "./native-turn-protocol";
+export type * from "./native-turn-protocol";
+/** A transport already admitted to one vault. Calls never own accepted work. */
+export interface NativeTurnService {
+    call(command: TurnCommand): Promise<TurnValue>;
+}
+import type { QueueCommand, QueueValue } from "./native-queue-protocol";
+export type * from "./native-queue-protocol";
+export { QUEUE_REQUEST_LIMIT, QUEUE_RECORD_LIMIT, } from "./native-queue-protocol";
+/**
+ * An admitted source-only queue transport; never retries uncertain acceptance.
+ * Native work outlives calls. Read retained state after a lost reply; cold
+ * resume requires the explicit current predecessor and never replays started
+ * entries.
+ */
+export interface NativeQueueService {
+    call(command: QueueCommand): Promise<QueueValue>;
+}
+import type { ParticipantCommand, ParticipantValue } from "./native-participant-protocol";
+export type * from "./native-participant-protocol";
+export { PARTICIPANT_PROFILE_LIMIT, PARTICIPANT_REQUEST_LIMIT, PARTICIPANT_RECORD_LIMIT, } from "./native-participant-protocol";
+/**
+ * An admitted participant port. Captured logical attribution never selects an
+ * installed runtime. A lost reply is observed by acceptance ID without replay;
+ * Stop/cancel request native cancellation without inventing terminal outcomes.
+ */
+export interface NativeParticipantService {
+    call(command: ParticipantCommand): Promise<ParticipantValue>;
+}

package/dist/native-turns.js

@@ -0,0 +1,2 @@
+export { QUEUE_REQUEST_LIMIT, QUEUE_RECORD_LIMIT, } from "./native-queue-protocol";
+export { PARTICIPANT_PROFILE_LIMIT, PARTICIPANT_REQUEST_LIMIT, PARTICIPANT_RECORD_LIMIT, } from "./native-participant-protocol";

package/dist/plugin-asset-server.js

@@ -1,3 +1,4 @@
+import { appStatePath } from "./storage/path";
 import { joinPath } from "./storage/path";
 import { assertSafePluginRelativePath } from "./plugin-distribution/path-safety";
 import { sha256Hex } from "./plugin-distribution/hashes";
@@ -62,7 +63,7 @@ export function getInstalledPluginAssetFingerprint(record) {
         sha256: normalizePluginAssetSha256(file.sha256),
         size: file.size,
     }))
-        .sort((left, right) => left.path.localeCompare(right.path))
+        .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0)
         .map((file) => `${file.path}:${file.size}:${file.sha256}`)
         .join("|");
 }
@@ -106,7 +107,7 @@ export function getPluginAssetContentType(path) {
     }
     return "application/octet-stream";
 }
-export async function readInstalledPluginAsset({ adapter, installedPlugin, relativePath, expectedSha256, pluginsPath = ".obsidian/plugins", verifyHash = true, }) {
+export async function readInstalledPluginAsset({ adapter, installedPlugin, relativePath, expectedSha256, pluginsPath = appStatePath("plugins"), verifyHash = true, }) {
     const path = normalizePluginAssetRelativePath(relativePath);
     assertSupportedPluginAssetPath(path);
     const metadata = getInstalledPluginAssetMetadata(installedPlugin, path);

package/dist/plugin-dependency-resolver.d.ts

@@ -3,7 +3,7 @@ export interface PluginDependencyContext {
     pluginId: string;
     pluginPath: string;
     manifest: PluginManifest;
-    host: "workspace" | "electron-renderer" | "electron-sidecar";
+    host: "workspace" | "tauri-desktop" | "electron-renderer" | "electron-sidecar";
     format: "commonjs" | "esm" | "node-esm";
 }
 export interface PluginSharedDependencyInfo {

package/dist/plugin-distribution/compatibility.d.ts

@@ -1,5 +1,5 @@
 import type { PluginCatalogEntry, PluginCatalogRelease, PluginCompatibilityInput, PluginCompatibilityResult, PluginReleaseManifest } from "./types";
 export declare const checkCatalogEntryCompatibility: (entry: PluginCatalogEntry, input: PluginCompatibilityInput) => PluginCompatibilityResult;
-export declare const checkCatalogReleaseCompatibility: (release: PluginCatalogRelease, input: PluginCompatibilityInput) => PluginCompatibilityResult;
+export declare const checkCatalogReleaseCompatibility: (release: PluginCatalogRelease, input: PluginCompatibilityInput, pluginId?: string) => PluginCompatibilityResult;
 export declare const checkReleaseManifestCompatibility: (manifest: PluginReleaseManifest, input: PluginCompatibilityInput) => PluginCompatibilityResult;
 export declare const compareVersions: (actual: string, required: string) => number;