@honua/app-platform 0.0.20-alpha.0

package/app-workspace/index.js

@@ -0,0 +1,722 @@
+/**
+ * Framework-neutral app workspace state orchestration for sample apps.
+ *
+ * The workspace composes existing Honua surfaces into typed state slices.
+ * Components dispatch reducer-style commands and subscribe to narrow slices or
+ * selectors; no component needs an imperative reference to another component.
+ *
+ * @experimental This entrypoint is not yet covered by the SDK's semver contract
+ *   — the surface may change in any minor release prior to `1.0.0`.
+ * @module
+ */
+import { isJobTerminal } from "../contract/index.js";
+import { EMPTY_STATE, featureSelectionKey, isSourceQualifiedSelectionTarget, selectLinkedViewQueryProjection, sourceFeatureSelectionTarget, } from "../exploration/index.js";
+import { emptyRealtimeFeatureState, realtimeFeatureKey, reduceRealtimeFeatureState, } from "../realtime/index.js";
+export const HONUA_SAVED_WORKSPACE_DOCUMENT_KIND = "honua.saved-workspace";
+export const HONUA_SAVED_WORKSPACE_DOCUMENT_VERSION = 1;
+export class HonuaAppWorkspace {
+    #state;
+    #listeners = new Map();
+    #externalUnsubscribers = new Set();
+    #disposed = false;
+    constructor(options = {}) {
+        this.#state = mergeInitialState(options.initialState);
+    }
+    get state() {
+        return this.#state;
+    }
+    dispatch(intent) {
+        this.#ensureLive("dispatch");
+        if (intent.kind === "attach-exploration-context") {
+            this.#attachExplorationContext(intent.context);
+        }
+        else if (intent.kind === "attach-job") {
+            this.#attachJob(intent.job);
+        }
+        const previous = this.#state;
+        const next = reduceAppWorkspaceState(previous, intent);
+        if (next === previous)
+            return;
+        this.#state = next;
+        const changedSlices = changedWorkspaceSlices(previous, next);
+        this.#emit({ state: next, previous, changedSlices, intent });
+    }
+    subscribe(slice, listener) {
+        this.#ensureLive("subscribe");
+        let listeners = this.#listeners.get(slice);
+        if (!listeners) {
+            listeners = new Set();
+            this.#listeners.set(slice, listeners);
+        }
+        listeners.add(listener);
+        return () => {
+            const set = this.#listeners.get(slice);
+            if (!set)
+                return;
+            set.delete(listener);
+            if (set.size === 0)
+                this.#listeners.delete(slice);
+        };
+    }
+    subscribeSelector(selector, listener, equality = Object.is) {
+        this.#ensureLive("subscribeSelector");
+        let selected = selector(this.#state);
+        return this.subscribe("all", (event) => {
+            const next = selector(event.state);
+            if (equality(selected, next))
+                return;
+            const previous = selected;
+            selected = next;
+            listener(next, previous);
+        });
+    }
+    snapshot() {
+        this.#ensureLive("snapshot");
+        return { version: 1, state: cloneValue(this.#state) };
+    }
+    restore(snapshot) {
+        this.dispatch({ kind: "restore-workspace-snapshot", snapshot });
+    }
+    applyDraft(draftId) {
+        this.#ensureLive("applyDraft");
+        const draft = this.#state.drafts.entries[draftId];
+        if (!draft)
+            throw new Error(`HonuaAppWorkspace draft ${draftId} was not found`);
+        this.dispatch(draft.proposedIntent);
+        this.dispatch({ kind: "remove-draft", draftId });
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        for (const unsubscribe of this.#externalUnsubscribers)
+            unsubscribe();
+        this.#externalUnsubscribers.clear();
+        this.#listeners.clear();
+    }
+    #attachExplorationContext(context) {
+        const unsubscribe = context.subscribe("all", () => {
+            if (this.#disposed)
+                return;
+            this.dispatch({
+                kind: "set-exploration",
+                reference: { datasetId: context.datasetId, sourceIds: context.sourceIds },
+                snapshot: context.snapshot(),
+            });
+        });
+        this.#externalUnsubscribers.add(unsubscribe);
+    }
+    #attachJob(job) {
+        const unsubscribe = job.watch((snapshot) => {
+            if (this.#disposed)
+                return;
+            this.dispatch({ kind: "set-job-snapshot", jobId: job.id, type: job.type, snapshot });
+        });
+        this.#externalUnsubscribers.add(unsubscribe);
+    }
+    #emit(event) {
+        const allListeners = this.#listeners.get("all");
+        if (allListeners) {
+            for (const listener of [...allListeners])
+                listener(event);
+        }
+        for (const slice of event.changedSlices) {
+            const listeners = this.#listeners.get(slice);
+            if (!listeners)
+                continue;
+            for (const listener of [...listeners])
+                listener(event);
+        }
+    }
+    #ensureLive(operation) {
+        if (this.#disposed) {
+            throw new Error(`HonuaAppWorkspace cannot ${operation} after dispose()`);
+        }
+    }
+}
+export function createHonuaAppWorkspace(options) {
+    return new HonuaAppWorkspace(options);
+}
+export function createHonuaSavedWorkspaceDocument(options) {
+    const snapshot = options.snapshot ?? (options.state ? { version: 1, state: cloneValue(options.state) } : undefined);
+    const state = snapshot?.state;
+    const savedAt = options.savedAt ?? new Date().toISOString();
+    const exploration = state ? selectWorkspaceExplorationState(state) : EMPTY_STATE;
+    return {
+        kind: HONUA_SAVED_WORKSPACE_DOCUMENT_KIND,
+        version: HONUA_SAVED_WORKSPACE_DOCUMENT_VERSION,
+        migration: {
+            schemaVersion: HONUA_SAVED_WORKSPACE_DOCUMENT_VERSION,
+            savedAt,
+            ...cloneValue(options.migration ?? {}),
+        },
+        project: cloneValue(options.project),
+        session: options.session
+            ? cloneValue({
+                ...options.session,
+                activeViewId: options.session.activeViewId ?? state?.layout.activeViewId,
+            })
+            : state?.layout.activeViewId
+                ? { activeViewId: state.layout.activeViewId }
+                : undefined,
+        sources: cloneValue(options.sources ?? sourcesFromWorkspaceState(state)),
+        layers: cloneValue(options.layers ?? []),
+        styles: cloneValue(options.styles ?? []),
+        filters: cloneValue(exploration.filters),
+        savedQueries: cloneValue(options.savedQueries ?? []),
+        selectedFeatures: cloneValue(selectedFeaturesFromWorkspaceState(state)),
+        jobs: cloneValue(options.jobs ?? jobsFromWorkspaceState(state)),
+        analysisOutputs: cloneValue(options.analysisOutputs ?? []),
+        appSnapshot: snapshot ? cloneValue(snapshot) : undefined,
+        metadata: options.metadata ? cloneValue(options.metadata) : undefined,
+    };
+}
+export function validateHonuaSavedWorkspaceDocument(value) {
+    const errors = [];
+    if (!isRecord(value)) {
+        return { ok: false, errors: [{ path: "$", message: "document must be an object" }] };
+    }
+    if (value.kind !== HONUA_SAVED_WORKSPACE_DOCUMENT_KIND) {
+        errors.push({ path: "$.kind", message: `must be ${HONUA_SAVED_WORKSPACE_DOCUMENT_KIND}` });
+    }
+    if (value.version !== HONUA_SAVED_WORKSPACE_DOCUMENT_VERSION) {
+        errors.push({ path: "$.version", message: "unsupported saved workspace document version" });
+    }
+    if (!isRecord(value.migration)) {
+        errors.push({ path: "$.migration", message: "migration metadata is required" });
+    }
+    else {
+        if (value.migration.schemaVersion !== HONUA_SAVED_WORKSPACE_DOCUMENT_VERSION) {
+            errors.push({ path: "$.migration.schemaVersion", message: "unsupported migration schema version" });
+        }
+        if (typeof value.migration.savedAt !== "string") {
+            errors.push({ path: "$.migration.savedAt", message: "savedAt must be a string" });
+        }
+    }
+    if (!isRecord(value.project)) {
+        errors.push({ path: "$.project", message: "project is required" });
+    }
+    else if (typeof value.project.id !== "string" || value.project.id.length === 0) {
+        errors.push({ path: "$.project.id", message: "project id must be a non-empty string" });
+    }
+    validateArrayWithIds(value.sources, "$.sources", errors);
+    validateArrayWithIds(value.layers, "$.layers", errors);
+    validateArrayWithIds(value.styles, "$.styles", errors);
+    validateArrayWithIds(value.savedQueries, "$.savedQueries", errors);
+    validateArrayWithIds(value.analysisOutputs, "$.analysisOutputs", errors);
+    if (!isRecord(value.filters)) {
+        errors.push({ path: "$.filters", message: "filters must be an object" });
+    }
+    if (!Array.isArray(value.selectedFeatures)) {
+        errors.push({ path: "$.selectedFeatures", message: "selectedFeatures must be an array" });
+    }
+    else {
+        value.selectedFeatures.forEach((entry, index) => {
+            if (!isRecord(entry)) {
+                errors.push({ path: `$.selectedFeatures[${index}]`, message: "selected feature must be an object" });
+            }
+            else if (typeof entry.id !== "string" && typeof entry.id !== "number") {
+                errors.push({
+                    path: `$.selectedFeatures[${index}].id`,
+                    message: "selected feature id must be string or number",
+                });
+            }
+        });
+    }
+    if (!Array.isArray(value.jobs)) {
+        errors.push({ path: "$.jobs", message: "jobs must be an array" });
+    }
+    else {
+        value.jobs.forEach((entry, index) => {
+            if (!isRecord(entry)) {
+                errors.push({ path: `$.jobs[${index}]`, message: "job must be an object" });
+                return;
+            }
+            if (typeof entry.id !== "string" || entry.id.length === 0) {
+                errors.push({ path: `$.jobs[${index}].id`, message: "job id must be a non-empty string" });
+            }
+            if (typeof entry.type !== "string" || entry.type.length === 0) {
+                errors.push({ path: `$.jobs[${index}].type`, message: "job type must be a non-empty string" });
+            }
+            if (!isSupportedJobStatus(entry.status)) {
+                errors.push({ path: `$.jobs[${index}].status`, message: "job status is not supported" });
+            }
+        });
+    }
+    if (value.appSnapshot !== undefined) {
+        if (!isRecord(value.appSnapshot)) {
+            errors.push({ path: "$.appSnapshot", message: "appSnapshot must be an object" });
+        }
+        else {
+            if (value.appSnapshot.version !== 1) {
+                errors.push({ path: "$.appSnapshot.version", message: "unsupported app workspace snapshot version" });
+            }
+            if (!isRecord(value.appSnapshot.state)) {
+                errors.push({ path: "$.appSnapshot.state", message: "appSnapshot state is required" });
+            }
+        }
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    return {
+        ok: true,
+        document: cloneValue(value),
+    };
+}
+export function assertHonuaSavedWorkspaceDocument(value) {
+    const validation = validateHonuaSavedWorkspaceDocument(value);
+    if (validation.ok)
+        return validation.document;
+    const message = validation.errors.map((error) => `${error.path}: ${error.message}`).join("; ");
+    throw new Error(`Invalid Honua saved workspace document: ${message}`);
+}
+export function hydrateHonuaSavedWorkspaceState(value, options = {}) {
+    const document = reattachHonuaSavedWorkspaceArtifacts(assertHonuaSavedWorkspaceDocument(value), options);
+    if (document.appSnapshot) {
+        return applySavedWorkspaceJobsToState(cloneValue(document.appSnapshot.state), document.jobs);
+    }
+    return stateFromSavedWorkspaceDocument(document);
+}
+export function createHonuaAppWorkspaceFromSavedDocument(value, options = {}) {
+    return createHonuaAppWorkspace({
+        initialState: hydrateHonuaSavedWorkspaceState(value, options),
+    });
+}
+export function reattachHonuaSavedWorkspaceArtifacts(value, options = {}) {
+    const jobsById = options.jobsById ?? {};
+    const analysisOutputsById = options.analysisOutputsById ?? {};
+    const analysisOutputIds = new Set(value.analysisOutputs.map((output) => output.id));
+    const extraOutputs = Object.values(analysisOutputsById).filter((output) => !analysisOutputIds.has(output.id));
+    return {
+        ...cloneValue(value),
+        jobs: value.jobs.map((job) => ({ ...job, ...cloneValue(jobsById[job.id] ?? {}) })),
+        analysisOutputs: [
+            ...value.analysisOutputs.map((output) => cloneValue(analysisOutputsById[output.id] ?? output)),
+            ...cloneValue(extraOutputs),
+        ],
+    };
+}
+export function summarizeHonuaSavedWorkspaceForMcp(value) {
+    const document = assertHonuaSavedWorkspaceDocument(value);
+    return {
+        kind: "honua.workspace.summary",
+        workspaceId: document.project.id,
+        title: document.project.title,
+        savedAt: document.migration.savedAt,
+        schemaVersion: document.version,
+        sourceCount: document.sources.length,
+        layerCount: document.layers.length,
+        savedQueryCount: document.savedQueries.length,
+        selectedFeatureCount: document.selectedFeatures.length,
+        jobCount: document.jobs.length,
+        analysisOutputCount: document.analysisOutputs.length,
+        sources: document.sources.map(({ id, protocol, title, status }) => ({ id, protocol, title, status })),
+        layers: document.layers.map(({ id, sourceId, title, visible }) => ({ id, sourceId, title, visible })),
+        savedQueries: document.savedQueries.map(({ id, label, sourceIds }) => ({ id, label, sourceIds })),
+        jobs: document.jobs.map(({ id, type, status, outputIds }) => ({ id, type, status, outputIds })),
+        analysisOutputs: document.analysisOutputs.map(({ id, jobId, type, label, sourceId, layerId }) => ({
+            id,
+            jobId,
+            type,
+            label,
+            sourceId,
+            layerId,
+        })),
+    };
+}
+export function bindHonuaAppWorkspaceSelector(workspace, selector, listener, options = {}) {
+    if (options.fireImmediately) {
+        const selected = selector(workspace.state);
+        listener(selected, selected);
+    }
+    return workspace.subscribeSelector(selector, listener, options.equality);
+}
+export function selectHonuaAppWorkspaceMapModel(state, options = {}) {
+    const exploration = selectWorkspaceExplorationState(state);
+    const sourceStatuses = {};
+    for (const [sourceId, entry] of Object.entries(state.sources.entries)) {
+        sourceStatuses[sourceId] = entry.status;
+    }
+    return {
+        extent: exploration.extent,
+        spatialFilter: exploration.spatialFilter,
+        selection: exploration.selection,
+        sourceStatuses,
+        sources: state.sources.entries,
+        query: selectLinkedViewQueryProjection(exploration, options),
+    };
+}
+export function selectHonuaAppWorkspaceTableModel(state, options = {}) {
+    return {
+        query: selectLinkedViewQueryProjection(selectWorkspaceExplorationState(state), options),
+        records: selectRealtimeRecords(state.realtime.features, options.sourceId),
+        source: options.sourceId ? state.sources.entries[options.sourceId] : undefined,
+    };
+}
+export function selectHonuaAppWorkspaceDetailModel(state) {
+    const exploration = selectWorkspaceExplorationState(state);
+    const selectedRecords = [];
+    const tombstones = [];
+    const missingSelection = [];
+    const seen = new Set();
+    for (const target of exploration.selection) {
+        const selectionKey = featureSelectionKey(target);
+        if (seen.has(selectionKey))
+            continue;
+        seen.add(selectionKey);
+        const key = realtimeKeyForSelection(target);
+        const record = state.realtime.features.records[key];
+        if (record) {
+            selectedRecords.push(record);
+            continue;
+        }
+        const tombstone = state.realtime.features.tombstones[key];
+        if (tombstone) {
+            tombstones.push(tombstone);
+            continue;
+        }
+        missingSelection.push(target);
+    }
+    return {
+        selection: exploration.selection,
+        selectedRecords,
+        tombstones,
+        missingSelection,
+    };
+}
+export function selectHonuaAppWorkspaceFilterModel(state) {
+    const exploration = selectWorkspaceExplorationState(state);
+    return {
+        filters: exploration.filters,
+        spatialFilter: exploration.spatialFilter,
+        extent: exploration.extent,
+    };
+}
+export function selectHonuaAppWorkspaceChartModel(state, options = {}) {
+    const exploration = selectWorkspaceExplorationState(state);
+    return {
+        query: selectLinkedViewQueryProjection(exploration, options),
+        grouping: exploration.grouping,
+        aggregation: exploration.aggregation,
+    };
+}
+export function selectHonuaAppWorkspaceJobModel(state) {
+    const entries = Object.values(state.jobs.entries);
+    return {
+        entries: state.jobs.entries,
+        running: entries.filter((entry) => !isJobTerminal(entry.snapshot.status)),
+        terminal: entries.filter((entry) => isJobTerminal(entry.snapshot.status)),
+    };
+}
+export function selectHonuaAppWorkspaceRealtimeModel(state, options = {}) {
+    const realtime = state.realtime.features;
+    return {
+        status: realtime.status,
+        cursor: realtime.cursor,
+        watermark: realtime.watermark,
+        records: selectRealtimeRecords(realtime, options.sourceId),
+        tombstones: selectRealtimeTombstones(realtime, options.sourceId),
+        ignoredEventCount: realtime.ignoredEventCount,
+    };
+}
+export function selectHonuaAppWorkspaceMetadataCacheModel(state) {
+    const entries = Object.values(state.sources.entries);
+    return {
+        entries: state.sources.entries,
+        loading: entries.filter((entry) => entry.status === "loading"),
+        ready: entries.filter((entry) => entry.status === "ready"),
+        stale: entries.filter((entry) => entry.status === "stale"),
+        errors: entries.filter((entry) => entry.status === "error"),
+    };
+}
+export function selectHonuaAppWorkspaceDrafts(state) {
+    return state.drafts;
+}
+function reduceAppWorkspaceState(state, intent) {
+    switch (intent.kind) {
+        case "set-exploration":
+            return withSlice(state, "exploration", {
+                reference: intent.reference ? cloneValue(intent.reference) : undefined,
+                snapshot: intent.snapshot ? cloneValue(intent.snapshot) : undefined,
+            });
+        case "attach-exploration-context":
+            return withSlice(state, "exploration", {
+                reference: { datasetId: intent.context.datasetId, sourceIds: [...intent.context.sourceIds] },
+                snapshot: intent.context.snapshot(),
+            });
+        case "restore-exploration-snapshot":
+            return withSlice(state, "exploration", {
+                reference: state.exploration.reference,
+                snapshot: cloneValue(intent.snapshot),
+            });
+        case "set-source-metadata":
+            return withSlice(state, "sources", {
+                entries: {
+                    ...state.sources.entries,
+                    [intent.sourceId]: {
+                        sourceId: intent.sourceId,
+                        status: intent.status,
+                        metadata: intent.metadata !== undefined ? cloneValue(intent.metadata) : undefined,
+                        updatedAt: intent.updatedAt,
+                        error: intent.error,
+                    },
+                },
+            });
+        case "clear-source-metadata": {
+            if (!intent.sourceId)
+                return withSlice(state, "sources", { entries: {} });
+            if (!state.sources.entries[intent.sourceId])
+                return state;
+            const entries = { ...state.sources.entries };
+            delete entries[intent.sourceId];
+            return withSlice(state, "sources", { entries });
+        }
+        case "apply-realtime-event":
+            return withSlice(state, "realtime", {
+                features: reduceRealtimeFeatureState(state.realtime.features, intent.event),
+            });
+        case "set-realtime-state":
+            return withSlice(state, "realtime", { features: cloneValue(intent.state) });
+        case "set-job-snapshot":
+            return withSlice(state, "jobs", {
+                entries: {
+                    ...state.jobs.entries,
+                    [intent.jobId]: { id: intent.jobId, type: intent.type, snapshot: cloneValue(intent.snapshot) },
+                },
+            });
+        case "attach-job":
+            return withSlice(state, "jobs", {
+                entries: {
+                    ...state.jobs.entries,
+                    [intent.job.id]: {
+                        id: intent.job.id,
+                        type: intent.job.type,
+                        snapshot: { status: intent.job.status, progress: intent.job.progress },
+                    },
+                },
+            });
+        case "remove-job": {
+            if (!state.jobs.entries[intent.jobId])
+                return state;
+            const entries = { ...state.jobs.entries };
+            delete entries[intent.jobId];
+            return withSlice(state, "jobs", { entries });
+        }
+        case "set-layout":
+            return withSlice(state, "layout", cloneValue(intent.layout));
+        case "update-panel":
+            return withSlice(state, "layout", {
+                ...state.layout,
+                panels: {
+                    ...state.layout.panels,
+                    [intent.panelId]: {
+                        ...state.layout.panels[intent.panelId],
+                        ...intent.panel,
+                    },
+                },
+            });
+        case "set-active-view":
+            return withSlice(state, "layout", { ...state.layout, activeViewId: intent.viewId });
+        case "set-saved-state-metadata":
+            return withSlice(state, "layout", { ...state.layout, savedState: intent.metadata });
+        case "stage-draft":
+            return withSlice(state, "drafts", {
+                entries: {
+                    ...state.drafts.entries,
+                    [intent.draft.id]: cloneValue(intent.draft),
+                },
+                activeDraftId: intent.activate ? intent.draft.id : state.drafts.activeDraftId,
+            });
+        case "remove-draft": {
+            if (!state.drafts.entries[intent.draftId])
+                return state;
+            const entries = { ...state.drafts.entries };
+            delete entries[intent.draftId];
+            return withSlice(state, "drafts", {
+                entries,
+                activeDraftId: state.drafts.activeDraftId === intent.draftId ? undefined : state.drafts.activeDraftId,
+            });
+        }
+        case "clear-drafts":
+            return withSlice(state, "drafts", { entries: {} });
+        case "set-active-draft":
+            return withSlice(state, "drafts", { ...state.drafts, activeDraftId: intent.draftId });
+        case "restore-workspace-snapshot":
+            if (intent.snapshot.version !== 1) {
+                throw new Error(`HonuaAppWorkspace snapshot version ${String(intent.snapshot.version)} is not supported`);
+            }
+            return cloneValue(intent.snapshot.state);
+    }
+}
+function withSlice(state, slice, value) {
+    if (Object.is(state[slice], value))
+        return state;
+    return { ...state, [slice]: value };
+}
+function changedWorkspaceSlices(previous, next) {
+    const changed = new Set();
+    if (previous.exploration !== next.exploration)
+        changed.add("exploration");
+    if (previous.sources !== next.sources)
+        changed.add("sources");
+    if (previous.realtime !== next.realtime)
+        changed.add("realtime");
+    if (previous.jobs !== next.jobs)
+        changed.add("jobs");
+    if (previous.layout !== next.layout)
+        changed.add("layout");
+    if (previous.drafts !== next.drafts)
+        changed.add("drafts");
+    return changed;
+}
+function mergeInitialState(initial) {
+    return {
+        exploration: initial?.exploration ? cloneValue(initial.exploration) : {},
+        sources: initial?.sources ? cloneValue(initial.sources) : { entries: {} },
+        realtime: initial?.realtime ? cloneValue(initial.realtime) : { features: emptyRealtimeFeatureState() },
+        jobs: initial?.jobs ? cloneValue(initial.jobs) : { entries: {} },
+        layout: initial?.layout ? cloneValue(initial.layout) : { panels: {} },
+        drafts: initial?.drafts ? cloneValue(initial.drafts) : { entries: {} },
+    };
+}
+function selectWorkspaceExplorationState(state) {
+    return state.exploration.snapshot?.state ?? EMPTY_STATE;
+}
+function selectRealtimeRecords(state, sourceId) {
+    return Object.values(state.records).filter((record) => sourceId === undefined || record.sourceId === sourceId);
+}
+function selectRealtimeTombstones(state, sourceId) {
+    return Object.values(state.tombstones).filter((tombstone) => sourceId === undefined || tombstone.sourceId === sourceId);
+}
+function realtimeKeyForSelection(target) {
+    if (isSourceQualifiedSelectionTarget(target))
+        return realtimeFeatureKey(target.sourceId, target.id);
+    return realtimeFeatureKey(undefined, target);
+}
+function sourcesFromWorkspaceState(state) {
+    if (!state)
+        return [];
+    return Object.values(state.sources.entries).map((entry) => ({
+        id: entry.sourceId,
+        status: entry.status,
+        metadata: entry.metadata,
+    }));
+}
+function selectedFeaturesFromWorkspaceState(state) {
+    if (!state)
+        return [];
+    return selectWorkspaceExplorationState(state).selection.map((target) => {
+        if (isSourceQualifiedSelectionTarget(target)) {
+            return { sourceId: target.sourceId, id: target.id };
+        }
+        return { id: target };
+    });
+}
+function jobsFromWorkspaceState(state) {
+    if (!state)
+        return [];
+    return Object.values(state.jobs.entries).map((entry) => ({
+        id: entry.id,
+        type: entry.type,
+        status: entry.snapshot.status,
+        progress: entry.snapshot.progress,
+        result: entry.snapshot.result,
+        error: entry.snapshot.error,
+        outputIds: entry.snapshot.result ? Object.keys(entry.snapshot.result.outputs) : undefined,
+    }));
+}
+function stateFromSavedWorkspaceDocument(document) {
+    const sources = {};
+    for (const source of document.sources) {
+        sources[source.id] = {
+            sourceId: source.id,
+            status: source.status ?? "idle",
+            metadata: source.metadata,
+        };
+    }
+    const jobs = {};
+    for (const job of document.jobs) {
+        jobs[job.id] = {
+            id: job.id,
+            type: job.type,
+            snapshot: {
+                status: job.status,
+                progress: job.progress,
+                result: job.result,
+                error: job.error,
+            },
+        };
+    }
+    return {
+        exploration: {
+            reference: document.project.id || document.sources.length > 0
+                ? { datasetId: document.project.id, sourceIds: document.sources.map((source) => source.id) }
+                : undefined,
+            snapshot: {
+                version: 1,
+                state: {
+                    ...EMPTY_STATE,
+                    filters: cloneValue(document.filters),
+                    selection: document.selectedFeatures.map((feature) => feature.sourceId ? sourceFeatureSelectionTarget(feature.sourceId, feature.id) : feature.id),
+                },
+            },
+        },
+        sources: { entries: sources },
+        realtime: { features: emptyRealtimeFeatureState() },
+        jobs: { entries: jobs },
+        layout: {
+            activeViewId: document.session?.activeViewId,
+            panels: {},
+            savedState: {
+                id: document.project.id,
+                label: document.project.title,
+                savedAt: Date.parse(document.migration.savedAt),
+                version: String(document.version),
+            },
+        },
+        drafts: { entries: {} },
+    };
+}
+function applySavedWorkspaceJobsToState(state, jobs) {
+    if (jobs.length === 0)
+        return state;
+    const entries = { ...state.jobs.entries };
+    for (const job of jobs) {
+        entries[job.id] = {
+            id: job.id,
+            type: job.type,
+            snapshot: {
+                status: job.status,
+                progress: job.progress,
+                result: job.result,
+                error: job.error,
+            },
+        };
+    }
+    return { ...state, jobs: { entries } };
+}
+function validateArrayWithIds(value, path, errors) {
+    if (!Array.isArray(value)) {
+        errors.push({ path, message: "must be an array" });
+        return;
+    }
+    value.forEach((entry, index) => {
+        if (!isRecord(entry)) {
+            errors.push({ path: `${path}[${index}]`, message: "entry must be an object" });
+        }
+        else if (typeof entry.id !== "string" || entry.id.length === 0) {
+            errors.push({ path: `${path}[${index}].id`, message: "id must be a non-empty string" });
+        }
+    });
+}
+function isSupportedJobStatus(value) {
+    return (value === "accepted" || value === "running" || value === "successful" || value === "failed" || value === "dismissed");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue(value) {
+    if (typeof structuredClone === "function")
+        return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+}