@knowledge-medium/agent-cli 0.1.0

package/dist/kernel-types/src/plugins/quick-find/QuickFind.d.ts

@@ -0,0 +1,2 @@
+export declare function QuickFind(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=QuickFind.d.ts.map

package/dist/kernel-types/src/plugins/quick-find/QuickFind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuickFind.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/quick-find/QuickFind.tsx"],"names":[],"mappings":"AA+EA,wBAAgB,SAAS,mDAkBxB"}

package/dist/kernel-types/src/plugins/quick-find/events.d.ts

@@ -0,0 +1,2 @@
+export declare const toggleQuickFindEvent = "toggle-quick-find";
+//# sourceMappingURL=events.d.ts.map

package/dist/kernel-types/src/plugins/quick-find/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/quick-find/events.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,sBAAsB,CAAA"}

package/dist/kernel-types/src/plugins/quick-find/index.d.ts

@@ -0,0 +1,13 @@
+import { type HeaderItemContribution, type AppMountContribution } from '@/extensions/core.js';
+import type { AppExtension } from '@/extensions/facet.js';
+import { ActionContextTypes, type ActionConfig } from '@/shortcuts/types.js';
+export { QuickFindHeaderItem } from './HeaderItem.tsx';
+export { QuickFind } from './QuickFind.tsx';
+export { toggleQuickFindEvent } from './events.ts';
+export { RECENT_BLOCKS_LIMIT, pushRecentBlockId, recentBlockIdsProp } from './recents.ts';
+export declare const quickFindMount: AppMountContribution;
+export declare const QUICK_FIND_ACTION_ID = "quick_find";
+export declare const quickFindAction: ActionConfig<typeof ActionContextTypes.GLOBAL>;
+export declare const quickFindHeaderItem: HeaderItemContribution;
+export declare const quickFindPlugin: AppExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel-types/src/plugins/quick-find/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/quick-find/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAA;AAG7B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEzD,OAAO,EAAE,kBAAkB,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAO5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEzF,eAAO,MAAM,cAAc,EAAE,oBAG5B,CAAA;AAED,eAAO,MAAM,oBAAoB,eAAe,CAAA;AAEhD,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,OAAO,kBAAkB,CAAC,MAAM,CAW1E,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,sBAIjC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,YAa5B,CAAA"}

package/dist/kernel-types/src/plugins/quick-find/recents.d.ts

@@ -0,0 +1,13 @@
+import type { Block } from '@/data/block';
+export declare const RECENT_BLOCKS_LIMIT = 10;
+/** Recently-opened block-id MRU list. Per-device state — what *this*
+ *  device's user has just been looking at. Lives on the plugin's
+ *  ui-state sub-block (see `quickFindUIStateType`), scoped to UiState
+ *  so it stays in its own undo bucket. The sub-block has a deterministic
+ *  id derived from (workspace, user), so if it does sync the per-device
+ *  semantic still holds — each device's quick-find subtree is keyed
+ *  to that device's user identity. */
+export declare const recentBlockIdsProp: import("@/data/api").PropertySchema<string[]>;
+export declare const quickFindUIStateType: import("@/data/api").TypeContribution;
+export declare const pushRecentBlockId: (uiStateBlock: Block, blockId: string) => void;
+//# sourceMappingURL=recents.d.ts.map

package/dist/kernel-types/src/plugins/quick-find/recents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recents.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/quick-find/recents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAGzC,eAAO,MAAM,mBAAmB,KAAK,CAAA;AAErC;;;;;;sCAMsC;AACtC,eAAO,MAAM,kBAAkB,+CAI7B,CAAA;AAEF,eAAO,MAAM,oBAAoB,uCAI/B,CAAA;AAEF,eAAO,MAAM,iBAAiB,GAAI,cAAc,KAAK,EAAE,SAAS,MAAM,KAAG,IAIxE,CAAA"}

package/dist/kernel-types/src/plugins/quick-find/selection.d.ts

@@ -0,0 +1,40 @@
+import type { LinkTargetAliasMatch, LinkTargetBlockMatch } from '@/utils/linkTargetAutocomplete.js';
+export declare const quickFindAliasValue: (match: LinkTargetAliasMatch) => string;
+export declare const quickFindBlockValue: (match: LinkTargetBlockMatch) => string;
+export declare const quickFindCreateValue: (query: string) => string;
+export declare const quickFindDateValue: (iso: string) => string;
+export type QuickFindOpenTarget = 'jump' | 'stack';
+interface QuickFindModifierState {
+    shiftKey?: boolean;
+    metaKey?: boolean;
+    ctrlKey?: boolean;
+}
+interface QuickFindClickModifierState {
+    shiftKey?: boolean;
+}
+export declare const quickFindOpenTargetFromModifiers: ({ shiftKey, metaKey, ctrlKey, }: QuickFindModifierState) => QuickFindOpenTarget;
+export declare const quickFindOpenTargetFromClickModifiers: ({ shiftKey, }: QuickFindClickModifierState) => QuickFindOpenTarget;
+export type QuickFindSelectionAction = {
+    kind: 'create-page';
+    alias: string;
+    target: QuickFindOpenTarget;
+} | {
+    kind: 'open-date';
+    iso: string;
+    target: QuickFindOpenTarget;
+} | {
+    kind: 'open-block';
+    blockId: string;
+    target: QuickFindOpenTarget;
+};
+export declare const quickFindSelectionAction: (selectedValue: string, target: QuickFindOpenTarget) => QuickFindSelectionAction | null;
+interface SelectionArgs {
+    query: string;
+    aliases: LinkTargetAliasMatch[];
+    blocks: LinkTargetBlockMatch[];
+    dateValues: string[];
+    currentValue: string;
+}
+export declare const nextQuickFindSelection: ({ query, aliases, blocks, dateValues, currentValue, }: SelectionArgs) => string;
+export {};
+//# sourceMappingURL=selection.d.ts.map

package/dist/kernel-types/src/plugins/quick-find/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/quick-find/selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,mCAAmC,CAAA;AAE1C,eAAO,MAAM,mBAAmB,GAAI,OAAO,oBAAoB,WACvB,CAAA;AAExC,eAAO,MAAM,mBAAmB,GAAI,OAAO,oBAAoB,WACrC,CAAA;AAE1B,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,WAAsB,CAAA;AAExE,eAAO,MAAM,kBAAkB,GAAI,KAAK,MAAM,WAAkB,CAAA;AAEhE,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,OAAO,CAAA;AAElD,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,UAAU,2BAA2B;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,eAAO,MAAM,gCAAgC,GAAI,iCAI9C,sBAAsB,KAAG,mBACuB,CAAA;AAEnD,eAAO,MAAM,qCAAqC,GAAI,eAEnD,2BAA2B,KAAG,mBACJ,CAAA;AAE7B,MAAM,MAAM,wBAAwB,GAChC;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAC,GACjE;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAC,GAC7D;IAAC,IAAI,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAC,CAAA;AAEtE,eAAO,MAAM,wBAAwB,GACnC,eAAe,MAAM,EACrB,QAAQ,mBAAmB,KAC1B,wBAAwB,GAAG,IAW7B,CAAA;AAED,UAAU,aAAa;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,oBAAoB,EAAE,CAAA;IAC/B,MAAM,EAAE,oBAAoB,EAAE,CAAA;IAC9B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,eAAO,MAAM,sBAAsB,GAAI,uDAMpC,aAAa,KAAG,MAqBlB,CAAA"}

package/dist/kernel-types/src/plugins/references/codeMirrorExtensions.d.ts

@@ -0,0 +1,9 @@
+import type { CodeMirrorExtensionContribution } from '@/extensions/editor.js';
+/** References plugin CM contribution: theme + chrome diff workaround +
+ *  wikilink / blockref completion sources. Sources are built once per
+ *  editor mount (outside the languageData callback) so each instance
+ *  has stable identity across keystrokes. CM's single central
+ *  `autocompletion()` call walks `EditorState.languageData` and picks
+ *  up everything contributed via the `autocomplete` field. */
+export declare const referencesCodeMirrorExtensions: CodeMirrorExtensionContribution;
+//# sourceMappingURL=codeMirrorExtensions.d.ts.map

package/dist/kernel-types/src/plugins/references/codeMirrorExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeMirrorExtensions.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/codeMirrorExtensions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,+BAA+B,EAChC,MAAM,wBAAwB,CAAA;AA8J/B;;;;;8DAK8D;AAC9D,eAAO,MAAM,8BAA8B,EAAE,+BAW5C,CAAA"}

package/dist/kernel-types/src/plugins/references/dataExtension.d.ts

@@ -0,0 +1,3 @@
+import type { AppExtension } from '@/extensions/facet.js';
+export declare const referencesDataExtension: AppExtension;
+//# sourceMappingURL=dataExtension.d.ts.map

package/dist/kernel-types/src/plugins/references/dataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataExtension.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/dataExtension.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAMzD,eAAO,MAAM,uBAAuB,EAAE,YAMrC,CAAA"}

package/dist/kernel-types/src/plugins/references/index.d.ts

@@ -0,0 +1,3 @@
+import type { AppExtension } from '@/extensions/facet.js';
+export declare const referencesPlugin: AppExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel-types/src/plugins/references/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAQzD,eAAO,MAAM,gBAAgB,EAAE,YAS7B,CAAA"}

package/dist/kernel-types/src/plugins/references/invalidation.d.ts

@@ -0,0 +1,4 @@
+import type { InvalidationRule } from '@/data/invalidation.js';
+export declare const REFERENCES_TARGET_INVALIDATION_CHANNEL = "references.target";
+export declare const referencesInvalidationRule: InvalidationRule;
+//# sourceMappingURL=invalidation.d.ts.map

package/dist/kernel-types/src/plugins/references/invalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidation.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/invalidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAEjB,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,sCAAsC,sBAAsB,CAAA;AA6CzE,eAAO,MAAM,0BAA0B,EAAE,gBAcxC,CAAA"}

package/dist/kernel-types/src/plugins/references/localSchema.d.ts

@@ -0,0 +1,21 @@
+import type { LocalSchemaContribution, LocalSchemaDb } from '@/data/facets.js';
+export declare const CREATE_BLOCKS_WORKSPACE_REFERENCES_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_blocks_workspace_with_references\n  ON blocks (workspace_id)\n  WHERE deleted = 0 AND references_json != '[]'\n";
+/** Trigger-maintained directed-edge index over `blocks.references_json`,
+ *  one row per `(source, target, alias, source_field)` tuple. */
+export declare const CREATE_BLOCK_REFERENCES_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS block_references (\n    source_id    TEXT NOT NULL,\n    target_id    TEXT NOT NULL,\n    workspace_id TEXT NOT NULL,\n    alias        TEXT NOT NULL,\n    source_field TEXT NOT NULL DEFAULT '',\n    PRIMARY KEY (source_id, target_id, alias, source_field)\n  )\n";
+export declare const CREATE_BLOCK_REFERENCES_TARGET_INDEX_SQL = "\n  CREATE INDEX IF NOT EXISTS idx_block_references_target\n  ON block_references (target_id, workspace_id)\n";
+export declare const CREATE_BLOCKS_REFERENCES_INSERT_TRIGGER_SQL: string;
+export declare const CREATE_BLOCKS_REFERENCES_UPDATE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_references_update\n  AFTER UPDATE OF references_json, deleted, workspace_id ON blocks\n  BEGIN\n    DELETE FROM block_references WHERE source_id = NEW.id;\n    INSERT OR IGNORE INTO block_references (source_id, target_id, workspace_id, alias, source_field)\n    SELECT\n      NEW.id,\n      json_extract(je.value, '$.id'),\n      NEW.workspace_id,\n      json_extract(je.value, '$.alias'),\n      COALESCE(json_extract(je.value, '$.sourceField'), '')\n    FROM json_each(NEW.references_json) AS je\n    WHERE NEW.deleted = 0\n      AND typeof(json_extract(je.value, '$.id')) = 'text'\n      AND typeof(json_extract(je.value, '$.alias')) = 'text'\n      AND (\n        json_type(je.value, '$.sourceField') IS NULL\n        OR typeof(json_extract(je.value, '$.sourceField')) = 'text'\n      );\n  END\n";
+export declare const CREATE_BLOCKS_REFERENCES_DELETE_TRIGGER_SQL = "\n  CREATE TRIGGER IF NOT EXISTS blocks_references_delete\n  AFTER DELETE ON blocks\n  BEGIN\n    DELETE FROM block_references WHERE source_id = OLD.id;\n  END\n";
+export declare const BLOCK_REFERENCES_BACKFILL_MARKER_KEY = "block_references_backfill_v1";
+export declare const BLOCK_REFERENCES_SOURCE_FIELD_MARKER_KEY = "block_references_source_field_v1";
+export declare const SELECT_BLOCK_REFERENCES_BACKFILL_DONE_SQL = "\n  SELECT 1 FROM client_schema_state WHERE key = 'block_references_backfill_v1'\n";
+export declare const RECORD_BLOCK_REFERENCES_BACKFILL_DONE_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES ('block_references_backfill_v1', strftime('%s', 'now') * 1000)\n";
+export declare const SELECT_BLOCK_REFERENCES_SOURCE_FIELD_DONE_SQL = "\n  SELECT 1 FROM client_schema_state WHERE key = 'block_references_source_field_v1'\n";
+export declare const RECORD_BLOCK_REFERENCES_SOURCE_FIELD_DONE_SQL = "\n  INSERT OR REPLACE INTO client_schema_state (key, completed_at)\n  VALUES ('block_references_source_field_v1', strftime('%s', 'now') * 1000)\n";
+export declare const BACKFILL_BLOCK_REFERENCES_SQL = "\n  INSERT OR IGNORE INTO block_references (source_id, target_id, workspace_id, alias, source_field)\n  SELECT\n    b.id,\n    json_extract(je.value, '$.id'),\n    b.workspace_id,\n    json_extract(je.value, '$.alias'),\n    COALESCE(json_extract(je.value, '$.sourceField'), '')\n  FROM blocks b, json_each(b.references_json) AS je\n  WHERE b.deleted = 0\n    AND typeof(json_extract(je.value, '$.id')) = 'text'\n    AND typeof(json_extract(je.value, '$.alias')) = 'text'\n    AND (\n      json_type(je.value, '$.sourceField') IS NULL\n      OR typeof(json_extract(je.value, '$.sourceField')) = 'text'\n    )\n";
+export declare const backfillBlockReferencesIfEmpty: (db: LocalSchemaDb) => Promise<void>;
+export declare const BLOCK_REFERENCES_TRIGGER_NAMES: readonly ["blocks_references_insert", "blocks_references_update", "blocks_references_delete"];
+export declare const backfillBlockReferencesSourceFieldIfNeeded: (db: LocalSchemaDb) => Promise<void>;
+export declare const referencesLocalSchema: LocalSchemaContribution;
+//# sourceMappingURL=localSchema.d.ts.map

package/dist/kernel-types/src/plugins/references/localSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localSchema.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/localSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAE9E,eAAO,MAAM,4CAA4C,uJAIxD,CAAA;AAED;iEACiE;AACjE,eAAO,MAAM,iCAAiC,0SAS7C,CAAA;AAED,eAAO,MAAM,wCAAwC,kHAGpD,CAAA;AAmBD,eAAO,MAAM,2CAA2C,QAOvD,CAAA;AAED,eAAO,MAAM,2CAA2C,60BAqBvD,CAAA;AAED,eAAO,MAAM,2CAA2C,sKAMvD,CAAA;AAED,eAAO,MAAM,oCAAoC,iCAAiC,CAAA;AAClF,eAAO,MAAM,wCAAwC,qCAAqC,CAAA;AAE1F,eAAO,MAAM,yCAAyC,uFAErD,CAAA;AAED,eAAO,MAAM,yCAAyC,kJAGrD,CAAA;AAED,eAAO,MAAM,6CAA6C,2FAEzD,CAAA;AAED,eAAO,MAAM,6CAA6C,sJAGzD,CAAA;AAED,eAAO,MAAM,6BAA6B,umBAgBzC,CAAA;AAED,eAAO,MAAM,8BAA8B,GACzC,IAAI,aAAa,KAChB,OAAO,CAAC,IAAI,CAKd,CAAA;AAED,eAAO,MAAM,8BAA8B,+FAIjC,CAAA;AAEV,eAAO,MAAM,0CAA0C,GACrD,IAAI,aAAa,KAChB,OAAO,CAAC,IAAI,CAed,CAAA;AAED,eAAO,MAAM,qBAAqB,EAAE,uBAqBnC,CAAA"}

package/dist/kernel-types/src/plugins/references/markdown/blockrefs/index.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownExtension } from '@/markdown/extensions.js';
+export declare const blockrefMarkdownExtension: MarkdownExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/blockrefs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/blockrefs/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAwBjE,eAAO,MAAM,yBAAyB,EAAE,iBActC,CAAA"}

package/dist/kernel-types/src/plugins/references/markdown/blockrefs/remark-blockrefs.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from 'unified';
+export declare const remarkBlockrefs: Plugin;
+//# sourceMappingURL=remark-blockrefs.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/blockrefs/remark-blockrefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remark-blockrefs.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/blockrefs/remark-blockrefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAuBhC,eAAO,MAAM,eAAe,EAAE,MA0C7B,CAAA"}

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/Wikilink.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import type { Block } from '@/data/block';
+export declare function Wikilink({ alias, blockId, sourceBlock, workspaceId, hasCustomDisplay, children }: {
+    alias: string;
+    blockId: string;
+    sourceBlock?: Block;
+    workspaceId: string;
+    /** True when the markdown source carried an explicit display label, as
+     *  in `[display]([[alias]])`. Display-decorators are bypassed in that
+     *  case so the author's intent isn't silently overridden. */
+    hasCustomDisplay?: boolean;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Wikilink.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/Wikilink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wikilink.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/wikilinks/Wikilink.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAQjC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEzC,wBAAgB,QAAQ,CAAC,EAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAwB,EAAE,QAAQ,EAAC,EAAE;IACvG,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,KAAK,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB;;iEAE6D;IAC7D,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,EAAE,SAAS,CAAA;CACpB,2CAgCA"}

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/index.d.ts

@@ -0,0 +1,3 @@
+import type { MarkdownExtension } from '@/markdown/extensions.js';
+export declare const wikilinkMarkdownExtension: MarkdownExtension;
+//# sourceMappingURL=index.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/wikilinks/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAkBjE,eAAO,MAAM,yBAAyB,EAAE,iBA2CvC,CAAA"}

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/remark-wikilinks.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'unified';
+export interface RemarkWikilinksOptions {
+    resolveAlias: (alias: string) => string | undefined;
+}
+export declare const remarkWikilinks: Plugin<[RemarkWikilinksOptions?]>;
+//# sourceMappingURL=remark-wikilinks.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/remark-wikilinks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remark-wikilinks.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/wikilinks/remark-wikilinks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAKhC,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;CACpD;AAmFD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,CAAC,sBAAsB,CAAC,CAAC,CA8G7D,CAAA"}

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/wikilinkDecorator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Facet for plugins to override the *display* of a wikilink without
+ * touching its underlying alias, link target, or storage. The first
+ * decorator (by precedence order) to return a non-null value wins;
+ * a null/undefined return falls through to the next decorator and
+ * ultimately to the wikilink's default rendering (the alias text).
+ *
+ * Decorators receive the full link context so they can make
+ * resolution-aware decisions — e.g. render differently when the alias
+ * resolved to no block yet, or scope behavior per workspace.
+ *
+ * Used by daily-notes to prefix date references with the weekday
+ * ("Fri, April 26th, 2026") at render time, while the stored alias
+ * remains the canonical "April 26th, 2026" the link resolver depends on.
+ */
+import { type ReactNode } from 'react';
+import type { Block } from '@/data/block';
+import { type FacetRuntime } from '@/extensions/facet.js';
+export interface WikilinkDisplayContext {
+    alias: string;
+    /** Resolved block id, or '' when the alias didn't match any block. */
+    blockId: string;
+    /** Block whose markdown content contains this wikilink. */
+    sourceBlock?: Block;
+    workspaceId: string;
+    /** Runtime available to display decorators that need to consult other facets. */
+    runtime?: FacetRuntime;
+}
+export interface WikilinkDisplayParts {
+    /** Content rendered inside the normal wikilink anchor. */
+    content: ReactNode;
+    /** Inline chrome rendered immediately before the anchor, outside the link. */
+    before?: ReactNode;
+    /** Inline chrome rendered immediately after the anchor, outside the link. */
+    after?: ReactNode;
+}
+export type WikilinkDisplayResult = ReactNode | WikilinkDisplayParts;
+export interface WikilinkDisplayDecorator {
+    /** Diagnostic id, also distinguishes decorators in tests. */
+    readonly id: string;
+    decorate: (context: WikilinkDisplayContext) => WikilinkDisplayResult | null;
+}
+export declare const wikilinkDisplayDecoratorFacet: import("@/extensions/facet.js").Facet<WikilinkDisplayDecorator, readonly WikilinkDisplayDecorator[]>;
+export declare const isWikilinkDisplayParts: (value: WikilinkDisplayResult | null) => value is WikilinkDisplayParts;
+/** First decorator (in precedence order) to return a non-null display,
+ *  or null if every decorator passes. Mirrors `pickBlockDateAdapter`'s
+ *  first-match semantics. */
+export declare const resolveWikilinkDisplay: (runtime: FacetRuntime, context: WikilinkDisplayContext) => WikilinkDisplayResult | null;
+//# sourceMappingURL=wikilinkDecorator.d.ts.map

package/dist/kernel-types/src/plugins/references/markdown/wikilinks/wikilinkDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wikilinkDecorator.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/plugins/references/markdown/wikilinks/wikilinkDecorator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AACtD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEtE,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,WAAW,CAAC,EAAE,KAAK,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,iFAAiF;IACjF,OAAO,CAAC,EAAE,YAAY,CAAA;CACvB;AAED,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,OAAO,EAAE,SAAS,CAAA;IAClB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,oBAAoB,CAAA;AAEpE,MAAM,WAAW,wBAAwB;IACvC,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,qBAAqB,GAAG,IAAI,CAAA;CAC5E;AAQD,eAAO,MAAM,6BAA6B,sGAMxC,CAAA;AAEF,eAAO,MAAM,sBAAsB,GACjC,OAAO,qBAAqB,GAAG,IAAI,KAClC,KAAK,IAAI,oBAKQ,CAAA;AAEpB;;6BAE6B;AAC7B,eAAO,MAAM,sBAAsB,GACjC,SAAS,YAAY,EACrB,SAAS,sBAAsB,KAC9B,qBAAqB,GAAG,IAO1B,CAAA"}

package/dist/kernel-types/src/plugins/references/referenceParser.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Reference parser + renderer for `[[alias]]` and `((block-id))`
+ * syntax. Owned by the references plugin — this is the canonical
+ * grammar for wikilinks and blockrefs across the codebase.
+ *
+ * Consumers (outside this plugin): the roam importer reads from
+ * here. Anything that emits the syntax should also use the
+ * `renderWikilink` / `renderAliasedBlockref` helpers below to avoid
+ * drift from parser expectations (`]]` cannot be represented
+ * exactly inside wikilink text, `]` / newlines in blockref labels,
+ * regex-meta + `$&` in aliases through `rewriteWikilinks`).
+ *
+ * Plain-text parsing here is preferred over the markdown-aware
+ * variant for hot paths; the markdown-aware fallback exists for
+ * surfaces that must skip code blocks (see `parseReferencesMarkdownAware`).
+ */
+export interface ParsedReference {
+    alias: string;
+    startIndex: number;
+    endIndex: number;
+}
+export interface ParsedBlockRef {
+    blockId: string;
+    startIndex: number;
+    endIndex: number;
+    embed: boolean;
+    label?: string;
+}
+export declare const isBlockRefId: (s: string) => boolean;
+export declare const parseBlockRefTarget: (target: string) => string | null;
+/**
+ * Parse every balanced `[[alias]]` pattern from text content. Nested
+ * wikilinks emit both the outer and inner references, matching Roam's
+ * backlink behavior.
+ */
+export declare function parseReferences(content: string): ParsedReference[];
+/**
+ * Parse only the outermost balanced `[[alias]]` spans. Use this when a
+ * caller needs token boundaries for text rewriting/rendering, where
+ * overlapping nested spans would corrupt slicing.
+ */
+export declare function parseOutermostReferences(content: string): ParsedReference[];
+/**
+ * Parse references using remark for markdown-aware extraction
+ * This version respects markdown structure (ignores code blocks, etc.)
+ */
+export declare function parseReferencesMarkdownAware(content: string): ParsedReference[];
+/**
+ * Extract just the alias strings from content
+ * @param content The text content to parse
+ * @returns Array of unique alias strings found
+ */
+export declare function extractAliases(content: string): string[];
+/**
+ * Check if content contains any references
+ * @param content The text content to check
+ * @returns True if content contains [[alias]] patterns
+ */
+export declare function hasReferences(content: string): boolean;
+/**
+ * Parse `((uuid))` block-refs, `!((uuid))` block-embeds, and Roam-style
+ * `[label](((uuid)))` aliased block refs out of text. More specific forms are
+ * matched first so their inner `((uuid))` spans are not double-counted.
+ */
+export declare function parseBlockRefs(content: string): ParsedBlockRef[];
+export declare function extractBlockRefIds(content: string): string[];
+/** Render a wikilink targeting `alias`. If `alias` contains the closing
+ *  wikilink delimiter, the output is syntactically safe but lossy;
+ *  callers that need alias identity must verify by parsing the result. */
+export declare const renderWikilink: (alias: string) => string;
+/** Render an aliased blockref `[label](((id)))`. Strips `]` and
+ *  newlines from `label` because the parser's regex rejects them in
+ *  the label segment (see `ALIASED_BLOCK_REF_RE`). `id` is assumed
+ *  to be a UUID — already safe. */
+export declare const renderAliasedBlockref: (label: string, id: string) => string;
+/** Replace every wikilink whose alias exactly matches `alias` with
+ *  the literal `replacement` string. Uses `parseReferences` to find
+ *  spans and avoids the
+ *  `String.replace` regex-replacement-string pitfall where `$&`,
+ *  `$1`, etc. in `replacement` would be interpreted as backreferences
+ *  rather than literals. Returns the input unchanged when no span
+ *  matches. */
+export declare const rewriteWikilinks: (content: string, alias: string, replacement: string) => string;
+//# sourceMappingURL=referenceParser.d.ts.map

package/dist/kernel-types/src/plugins/references/referenceParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceParser.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/referenceParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAWD,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,YAAmD,CAAA;AAEzF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,MAAM,GAAG,IAG7D,CAAA;AAiCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAElE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAU3E;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAyB/E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAIxD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,EAAE,CAkDhE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAE5D;AAMD;;0EAE0E;AAC1E,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,MAM9C,CAAA;AAED;;;mCAGmC;AACnC,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,EAAE,IAAI,MAAM,KAAG,MAOjE,CAAA;AAED;;;;;;eAMe;AACf,eAAO,MAAM,gBAAgB,GAC3B,SAAS,MAAM,EACf,OAAO,MAAM,EACb,aAAa,MAAM,KAClB,MAiBF,CAAA"}

package/dist/kernel-types/src/plugins/references/referenceProjection.d.ts

@@ -0,0 +1,3 @@
+import { type AnyPropertySchema, type BlockData, type BlockReference } from '@/data/api';
+export declare const projectPropertyReferences: (source: Pick<BlockData, "properties">, propertySchemas: ReadonlyMap<string, AnyPropertySchema>) => BlockReference[];
+//# sourceMappingURL=referenceProjection.d.ts.map

package/dist/kernel-types/src/plugins/references/referenceProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referenceProjection.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/referenceProjection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,YAAY,CAAA;AAgBnB,eAAO,MAAM,yBAAyB,GACpC,QAAQ,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,EACrC,iBAAiB,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,KACtD,cAAc,EA8BhB,CAAA"}

package/dist/kernel-types/src/plugins/references/referencesProcessor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Reference parsing + orphan-alias cleanup post-commit processors (spec §7).
+ *
+ * `references.parseReferences`
+ *   - watches: { kind: 'field', table: 'blocks', fields: ['content', 'properties'] }
+ *   - For each changedRow whose `content` or `properties` changed (insert
+ *     or update), parse `[[alias]]` / `((uuid))` references and ref-typed
+ *     properties.
+ *   - Resolve aliases to existing target ids via a workspace-scoped
+ *     SQL lookup (committed-state read via ctx.db). On miss, create
+ *     the target via ensureAliasTarget / ensureDailyNoteTarget.
+ *   - Write `tx.update(sourceId, {references}, {skipMetadata: true})`.
+ *   - If any non-date alias target was newly inserted (or restored),
+ *     schedule `references.cleanupOrphanAliases` with
+ *     `{newlyInsertedAliasTargetIds}` after delayMs: 4000.
+ *   - Opens its own tx via `ctx.repo.tx(..., {scope:
+ *     ChangeScope.References})` — separate undo bucket; uploads.
+ *
+ * `references.cleanupOrphanAliases`
+ *   - watches: { kind: 'explicit' }
+ *   - scheduledArgsSchema: z.object({newlyInsertedAliasTargetIds: z.array(z.string())})
+ *     (validated at enqueue time so a bad arg fails the originating tx)
+ *   - For each candidate id: if no block currently references it,
+ *     `tx.delete(id)` (subtree-aware soft-delete via the kernel
+ *     mutator path? — for v1 just tx.delete since target blocks are
+ *     leaves).
+ *   - Date-shaped alias targets are excluded from the cleanup list at
+ *     parseReferences-schedule time (§7.6 daily-note exemption); this
+ *     processor only sees non-date ids.
+ *
+ * Why not in-tx parseReferences (§7.1): same-tx parsing would add
+ * typing latency to a hot path. Today's app already runs follow-up
+ * parsing fire-and-forget; the redesign keeps that shape.
+ *
+ * Two-phase shape (v4.32, see §5.7): both processors do their reads
+ * BEFORE opening a write tx. The framework no longer auto-wraps apply
+ * in a writeTransaction, so the read phase doesn't hold a writer slot
+ * and reads can't queue behind a writer-that-awaits-them (the
+ * `tasks/processor-tx-deadlock.md` shape). The write phase still uses a
+ * single tx for atomicity (target writes + references update +
+ * afterCommit schedule all commit together).
+ */
+import { type AnyPostCommitProcessor } from '@/data/api';
+export declare const PARSE_REFERENCES_PROCESSOR = "references.parseReferences";
+export declare const CLEANUP_ORPHAN_ALIASES_PROCESSOR = "references.cleanupOrphanAliases";
+export declare const parseReferencesProcessor: import("@/data/api").PostCommitProcessor<undefined>;
+interface CleanupArgs {
+    workspaceId: string;
+    newlyInsertedAliasTargetIds: string[];
+}
+declare module '@/data/api' {
+    interface PostCommitProcessorRegistry {
+        [CLEANUP_ORPHAN_ALIASES_PROCESSOR]: CleanupArgs;
+    }
+}
+export declare const cleanupOrphanAliasesProcessor: import("@/data/api").PostCommitProcessor<CleanupArgs>;
+export declare const referencesPostCommitProcessors: ReadonlyArray<AnyPostCommitProcessor>;
+export {};
+//# sourceMappingURL=referencesProcessor.d.ts.map

package/dist/kernel-types/src/plugins/references/referencesProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"referencesProcessor.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/referencesProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,EAML,KAAK,sBAAsB,EAK5B,MAAM,YAAY,CAAA;AAanB,eAAO,MAAM,0BAA0B,+BAA+B,CAAA;AACtE,eAAO,MAAM,gCAAgC,oCAAoC,CAAA;AA4JjF,eAAO,MAAM,wBAAwB,qDA6CnC,CAAA;AASF,UAAU,WAAW;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,2BAA2B,EAAE,MAAM,EAAE,CAAA;CACtC;AAED,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,2BAA2B;QACnC,CAAC,gCAAgC,CAAC,EAAE,WAAW,CAAA;KAChD;CACF;AAED,eAAO,MAAM,6BAA6B,uDAoCxC,CAAA;AAIF,eAAO,MAAM,8BAA8B,EAAE,aAAa,CAAC,sBAAsB,CAGhF,CAAA"}

package/dist/kernel-types/src/plugins/references/renameProcessor.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Alias-rename backlink rewriter (spec: docs/alias-rename-cases.html
+ * — rename ladder).
+ *
+ * Watches alias-property diffs on `blocks`. For each removed alias α
+ * with live backlinks (found via the `block_references` projection):
+ *
+ *   1. 1-for-1 swap (|removed| = |added| = 1) — R1, R2, A1-cascade,
+ *      AR1-cascade: rewrite `[[α]] → [[new]]` in source content.
+ *   2. Anything else with backlinks (R4, R5, R6, R7, A2-cascade):
+ *      rewrite `[[α]] → [α](((target-id)))` (aliased blockref).
+ *      Preserves the display text the source author wrote; doesn't
+ *      depend on what's left in `aliases`.
+ *   3. Pure add (no removed aliases) — R3: no-op.
+ *
+ * Lives next to `parseReferencesProcessor` in the references plugin
+ * because it needs the `block_references` projection to find source
+ * blocks.
+ *
+ * Two-phase shape mirrors parseReferences: read phase outside any tx
+ * builds a plan describing per-source rewrites AND records the source
+ * content observed at decision time. Write phase opens one tx,
+ * re-reads source content via `tx.get`, and skips the source entirely
+ * if content has changed (later user edit wins — see `applyPlan`).
+ * Otherwise applies the rewrites via parser-aware span splicing
+ * (`rewriteWikilinks`) AND surgically swaps the matching `references`
+ * entries in the same tx so the `block_references` trigger refreshes
+ * in lockstep. Without that, a second rapid rename's SELECT would
+ * race the separate parseReferences processor and miss the source —
+ * leaving the backlink stuck on an alias the target no longer carries.
+ *
+ * Idempotency: the rewrite produces source content that no longer
+ * contains `[[α]]`, so a second pass over the same source content is
+ * a no-op (no matching span). Rename doesn't re-fire on the source
+ * content edit because its watcher is `properties`-only.
+ */
+import { type AnyPostCommitProcessor } from '@/data/api';
+export declare const RENAME_BACKLINKS_PROCESSOR = "references.renameBacklinks";
+/** Replacement form for a single removed alias α. Returns both the
+ *  literal text spliced into source content AND the alias that should
+ *  appear in the source's `references` entry for this target after
+ *  the rewrite (so the inline references update mirrors what
+ *  parseReferences would emit on a re-parse of the new content). */
+export interface Replacement {
+    /** Text spliced into source content in place of `[[α]]`. */
+    text: string;
+    /** Alias the corresponding `BlockReference` carries after the
+     *  rewrite. Wikilink form → the new alias `β`. Blockref form →
+     *  the target id (parseReferences sets `alias === id` for blockref
+     *  edges; see referencesProcessor.ts buildSourcePlan). */
+    refAlias: string;
+}
+export declare const replacementFor: (alias: string, removed: readonly string[], added: readonly string[], targetId: string) => Replacement;
+export declare const renameBacklinksProcessor: import("@/data/api").PostCommitProcessor<undefined>;
+export declare const renamePostCommitProcessors: ReadonlyArray<AnyPostCommitProcessor>;
+//# sourceMappingURL=renameProcessor.d.ts.map

package/dist/kernel-types/src/plugins/references/renameProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renameProcessor.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/references/renameProcessor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAIL,KAAK,sBAAsB,EAM5B,MAAM,YAAY,CAAA;AASnB,eAAO,MAAM,0BAA0B,+BAA+B,CAAA;AA2BtE;;;;oEAIoE;AACpE,MAAM,WAAW,WAAW;IAC1B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAA;IACZ;;;8DAG0D;IAC1D,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,SAAS,SAAS,MAAM,EAAE,EAC1B,OAAO,SAAS,MAAM,EAAE,EACxB,UAAU,MAAM,KACf,WAqBF,CAAA;AA6KD,eAAO,MAAM,wBAAwB,qDAwBnC,CAAA;AAEF,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,sBAAsB,CAE5E,CAAA"}

package/dist/kernel-types/src/plugins/roam-import/action.d.ts

@@ -0,0 +1,6 @@
+import type { Repo } from '@/data/repo';
+import { ActionConfig } from '@/shortcuts/types.js';
+export declare const importRoamAction: ({ repo }: {
+    repo: Repo;
+}) => ActionConfig;
+//# sourceMappingURL=action.d.ts.map

package/dist/kernel-types/src/plugins/roam-import/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/roam-import/action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EACL,YAAY,EAEb,MAAM,sBAAsB,CAAA;AAM7B,eAAO,MAAM,gBAAgB,GAAI,UAAQ;IAAC,IAAI,EAAE,IAAI,CAAA;CAAC,KAAG,YAqEtD,CAAA"}

package/dist/kernel-types/src/plugins/roam-import/content.d.ts

@@ -0,0 +1,9 @@
+export interface ContentRewriteResult {
+    content: string;
+    unresolvedBlockUids: string[];
+    embedPathTargets: string[];
+}
+export declare const collectContentRefUids: (content: string) => string[];
+export declare const rewriteRoamContent: (raw: string, uidMap: ReadonlyMap<string, string>) => ContentRewriteResult;
+export declare const applyHeading: (content: string, heading: number | undefined) => string;
+//# sourceMappingURL=content.d.ts.map

package/dist/kernel-types/src/plugins/roam-import/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/roam-import/content.ts"],"names":[],"mappings":"AA6CA,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,mBAAmB,EAAE,MAAM,EAAE,CAAA;IAC7B,gBAAgB,EAAE,MAAM,EAAE,CAAA;CAC3B;AASD,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,MAAM,EAiB7D,CAAA;AA2ND,eAAO,MAAM,kBAAkB,GAC7B,KAAK,MAAM,EACX,QAAQ,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,KAClC,oBAgCF,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,EAAE,SAAS,MAAM,GAAG,SAAS,KAAG,MAK3E,CAAA"}

package/dist/kernel-types/src/plugins/roam-import/effect.d.ts

@@ -0,0 +1,7 @@
+import type { AppEffect } from '@/extensions/core.js';
+/** Installs `window.__omniliner.roamImport` once per Repo so the agent
+ *  runtime / devtools console can kick off an import without the file
+ *  picker. `ensureRoamImportWindowHook` is idempotent — the AppEffect
+ *  surface re-runs across plugin reloads without leaking handlers. */
+export declare const roamImportWindowHookEffect: AppEffect;
+//# sourceMappingURL=effect.d.ts.map

package/dist/kernel-types/src/plugins/roam-import/effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/roam-import/effect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AAGrD;;;sEAGsE;AACtE,eAAO,MAAM,0BAA0B,EAAE,SAKxC,CAAA"}

package/dist/kernel-types/src/plugins/roam-import/ids.d.ts

@@ -0,0 +1,9 @@
+import type { RoamPage } from './types';
+export declare const ROAM_IMPORT_NS = "b8d6f1c2-7e9a-4f4d-a4f1-2c0a3a6e7f01";
+export declare const roamBlockId: (workspaceId: string, roamUid: string) => string;
+export interface DailyPageInfo {
+    iso: string;
+    blockId: string;
+}
+export declare const resolveDailyPage: (workspaceId: string, page: RoamPage) => DailyPageInfo | null;
+//# sourceMappingURL=ids.d.ts.map

package/dist/kernel-types/src/plugins/roam-import/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../../../../../../src/plugins/roam-import/ids.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKvC,eAAO,MAAM,cAAc,yCAAyC,CAAA;AAIpE,eAAO,MAAM,WAAW,GAAI,aAAa,MAAM,EAAE,SAAS,MAAM,KAAG,MACT,CAAA;AAE1D,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,MAAM,CAAA;CAChB;AAqBD,eAAO,MAAM,gBAAgB,GAC3B,aAAa,MAAM,EACnB,MAAM,QAAQ,KACb,aAAa,GAAG,IAiBlB,CAAA"}

package/dist/kernel-types/src/plugins/roam-import/import.d.ts

@@ -0,0 +1,37 @@
+import type { Repo } from '@/data/repo';
+import type { RoamExport } from './types';
+import { type RoamTypeCandidate } from './typeCandidates';
+import type { RoamMemoImportPlanSummary } from './roamMemo';
+export interface RoamImportOptions {
+    workspaceId: string;
+    currentUserId: string;
+    /** Don't write anything; return what would be written. */
+    dryRun?: boolean;
+    /** Surface progress / decisions for long imports. */
+    onProgress?: (msg: string) => void;
+    /** Override the default descendant-tx chunk size. Provided so tests
+     *  can exercise multi-chunk behaviour without generating thousands
+     *  of rows; production callers should leave this unset. */
+    descendantChunkSize?: number;
+}
+export interface RoamImportSummary {
+    pagesCreated: number;
+    pagesMerged: number;
+    pagesDaily: number;
+    blocksWritten: number;
+    aliasesResolved: number;
+    aliasBlocksCreated: number;
+    typeCandidates: RoamTypeCandidate[];
+    roamMemo: RoamMemoImportPlanSummary;
+    /**
+     * Empty stand-in blocks created for `((uid))` references whose target
+     * wasn't in this export. A future import that brings in the real
+     * blocks will upsert onto the same ids and replace the placeholder.
+     */
+    placeholdersCreated: number;
+    diagnostics: string[];
+    durationMs: number;
+    dryRun: boolean;
+}
+export declare const importRoam: (pages: RoamExport, repo: Repo, options: RoamImportOptions) => Promise<RoamImportSummary>;
+//# sourceMappingURL=import.d.ts.map