@powerhousedao/knowledge-note 1.0.0

package/dist/document-models/vault-config/v1/gen/actions.d.ts

@@ -0,0 +1,4 @@
+import type { VaultConfigConfigManagementAction } from "./config-management/actions.js";
+export * from "./config-management/actions.js";
+export type VaultConfigAction = VaultConfigConfigManagementAction;
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/vault-config/v1/gen/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,gCAAgC,CAAC;AAExF,cAAc,gCAAgC,CAAC;AAE/C,MAAM,MAAM,iBAAiB,GAAG,iCAAiC,CAAC"}

package/dist/document-models/vault-config/v1/gen/actions.js

@@ -0,0 +1 @@
+export * from "./config-management/actions.js";

package/dist/document-models/vault-config/v1/gen/config-management/actions.d.ts

@@ -0,0 +1,36 @@
+import type { Action } from "document-model";
+import type { InitializeConfigInput, UpdateDimensionInput, UpdateVocabularyInput, UpdatePipelineConfigInput, UpdateMaintenanceThresholdInput, AddExtractionCategoryInput, ToggleExtractionCategoryInput, ToggleFeatureInput } from "../types.js";
+export type InitializeConfigAction = Action & {
+    type: "INITIALIZE_CONFIG";
+    input: InitializeConfigInput;
+};
+export type UpdateDimensionAction = Action & {
+    type: "UPDATE_DIMENSION";
+    input: UpdateDimensionInput;
+};
+export type UpdateVocabularyAction = Action & {
+    type: "UPDATE_VOCABULARY";
+    input: UpdateVocabularyInput;
+};
+export type UpdatePipelineConfigAction = Action & {
+    type: "UPDATE_PIPELINE_CONFIG";
+    input: UpdatePipelineConfigInput;
+};
+export type UpdateMaintenanceThresholdAction = Action & {
+    type: "UPDATE_MAINTENANCE_THRESHOLD";
+    input: UpdateMaintenanceThresholdInput;
+};
+export type AddExtractionCategoryAction = Action & {
+    type: "ADD_EXTRACTION_CATEGORY";
+    input: AddExtractionCategoryInput;
+};
+export type ToggleExtractionCategoryAction = Action & {
+    type: "TOGGLE_EXTRACTION_CATEGORY";
+    input: ToggleExtractionCategoryInput;
+};
+export type ToggleFeatureAction = Action & {
+    type: "TOGGLE_FEATURE";
+    input: ToggleFeatureInput;
+};
+export type VaultConfigConfigManagementAction = InitializeConfigAction | UpdateDimensionAction | UpdateVocabularyAction | UpdatePipelineConfigAction | UpdateMaintenanceThresholdAction | AddExtractionCategoryAction | ToggleExtractionCategoryAction | ToggleFeatureAction;
+//# sourceMappingURL=actions.d.ts.map

package/dist/document-models/vault-config/v1/gen/config-management/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../../document-models/vault-config/v1/gen/config-management/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAC/B,0BAA0B,EAC1B,6BAA6B,EAC7B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG;IAC5C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC;AACF,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG;IAC3C,IAAI,EAAE,kBAAkB,CAAC;IACzB,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG;IAC5C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,qBAAqB,CAAC;CAC9B,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,MAAM,GAAG;IAChD,IAAI,EAAE,wBAAwB,CAAC;IAC/B,KAAK,EAAE,yBAAyB,CAAC;CAClC,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,MAAM,GAAG;IACtD,IAAI,EAAE,8BAA8B,CAAC;IACrC,KAAK,EAAE,+BAA+B,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG;IACjD,IAAI,EAAE,yBAAyB,CAAC;IAChC,KAAK,EAAE,0BAA0B,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,8BAA8B,GAAG,MAAM,GAAG;IACpD,IAAI,EAAE,4BAA4B,CAAC;IACnC,KAAK,EAAE,6BAA6B,CAAC;CACtC,CAAC;AACF,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG;IACzC,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,kBAAkB,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,iCAAiC,GACzC,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,0BAA0B,GAC1B,gCAAgC,GAChC,2BAA2B,GAC3B,8BAA8B,GAC9B,mBAAmB,CAAC"}

package/dist/document-models/vault-config/v1/gen/config-management/actions.js

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

package/dist/document-models/vault-config/v1/gen/config-management/creators.d.ts

@@ -0,0 +1,11 @@
+import type { InitializeConfigInput, UpdateDimensionInput, UpdateVocabularyInput, UpdatePipelineConfigInput, UpdateMaintenanceThresholdInput, AddExtractionCategoryInput, ToggleExtractionCategoryInput, ToggleFeatureInput } from "../types.js";
+import type { InitializeConfigAction, UpdateDimensionAction, UpdateVocabularyAction, UpdatePipelineConfigAction, UpdateMaintenanceThresholdAction, AddExtractionCategoryAction, ToggleExtractionCategoryAction, ToggleFeatureAction } from "./actions.js";
+export declare const initializeConfig: (input: InitializeConfigInput) => InitializeConfigAction;
+export declare const updateDimension: (input: UpdateDimensionInput) => UpdateDimensionAction;
+export declare const updateVocabulary: (input: UpdateVocabularyInput) => UpdateVocabularyAction;
+export declare const updatePipelineConfig: (input: UpdatePipelineConfigInput) => UpdatePipelineConfigAction;
+export declare const updateMaintenanceThreshold: (input: UpdateMaintenanceThresholdInput) => UpdateMaintenanceThresholdAction;
+export declare const addExtractionCategory: (input: AddExtractionCategoryInput) => AddExtractionCategoryAction;
+export declare const toggleExtractionCategory: (input: ToggleExtractionCategoryInput) => ToggleExtractionCategoryAction;
+export declare const toggleFeature: (input: ToggleFeatureInput) => ToggleFeatureAction;
+//# sourceMappingURL=creators.d.ts.map

package/dist/document-models/vault-config/v1/gen/config-management/creators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../../../../../document-models/vault-config/v1/gen/config-management/creators.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,+BAA+B,EAC/B,0BAA0B,EAC1B,6BAA6B,EAC7B,kBAAkB,EACnB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,gCAAgC,EAChC,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,gBAAgB,GAAI,OAAO,qBAAqB,2BAO1D,CAAC;AAEJ,eAAO,MAAM,eAAe,GAAI,OAAO,oBAAoB,0BAOxD,CAAC;AAEJ,eAAO,MAAM,gBAAgB,GAAI,OAAO,qBAAqB,2BAO1D,CAAC;AAEJ,eAAO,MAAM,oBAAoB,GAAI,OAAO,yBAAyB,+BAOlE,CAAC;AAEJ,eAAO,MAAM,0BAA0B,GACrC,OAAO,+BAA+B,qCAQrC,CAAC;AAEJ,eAAO,MAAM,qBAAqB,GAAI,OAAO,0BAA0B,gCAOpE,CAAC;AAEJ,eAAO,MAAM,wBAAwB,GACnC,OAAO,6BAA6B,mCAQnC,CAAC;AAEJ,eAAO,MAAM,aAAa,GAAI,OAAO,kBAAkB,wBAOpD,CAAC"}

package/dist/document-models/vault-config/v1/gen/config-management/creators.js

@@ -0,0 +1,10 @@
+import { createAction } from "document-model/core";
+import { InitializeConfigInputSchema, UpdateDimensionInputSchema, UpdateVocabularyInputSchema, UpdatePipelineConfigInputSchema, UpdateMaintenanceThresholdInputSchema, AddExtractionCategoryInputSchema, ToggleExtractionCategoryInputSchema, ToggleFeatureInputSchema, } from "../schema/zod.js";
+export const initializeConfig = (input) => createAction("INITIALIZE_CONFIG", { ...input }, undefined, InitializeConfigInputSchema, "global");
+export const updateDimension = (input) => createAction("UPDATE_DIMENSION", { ...input }, undefined, UpdateDimensionInputSchema, "global");
+export const updateVocabulary = (input) => createAction("UPDATE_VOCABULARY", { ...input }, undefined, UpdateVocabularyInputSchema, "global");
+export const updatePipelineConfig = (input) => createAction("UPDATE_PIPELINE_CONFIG", { ...input }, undefined, UpdatePipelineConfigInputSchema, "global");
+export const updateMaintenanceThreshold = (input) => createAction("UPDATE_MAINTENANCE_THRESHOLD", { ...input }, undefined, UpdateMaintenanceThresholdInputSchema, "global");
+export const addExtractionCategory = (input) => createAction("ADD_EXTRACTION_CATEGORY", { ...input }, undefined, AddExtractionCategoryInputSchema, "global");
+export const toggleExtractionCategory = (input) => createAction("TOGGLE_EXTRACTION_CATEGORY", { ...input }, undefined, ToggleExtractionCategoryInputSchema, "global");
+export const toggleFeature = (input) => createAction("TOGGLE_FEATURE", { ...input }, undefined, ToggleFeatureInputSchema, "global");

package/dist/document-models/vault-config/v1/gen/config-management/error.d.ts

@@ -0,0 +1,2 @@
+export declare const errors: {};
+//# sourceMappingURL=error.d.ts.map

package/dist/document-models/vault-config/v1/gen/config-management/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../../../../document-models/vault-config/v1/gen/config-management/error.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM,IAAK,CAAC"}

package/dist/document-models/vault-config/v1/gen/config-management/error.js

@@ -0,0 +1 @@
+export const errors = {};

package/dist/document-models/vault-config/v1/gen/config-management/operations.d.ts

@@ -0,0 +1,14 @@
+import { type SignalDispatch } from "document-model";
+import type { InitializeConfigAction, UpdateDimensionAction, UpdateVocabularyAction, UpdatePipelineConfigAction, UpdateMaintenanceThresholdAction, AddExtractionCategoryAction, ToggleExtractionCategoryAction, ToggleFeatureAction } from "./actions.js";
+import type { VaultConfigState } from "../types.js";
+export interface VaultConfigConfigManagementOperations {
+    initializeConfigOperation: (state: VaultConfigState, action: InitializeConfigAction, dispatch?: SignalDispatch) => void;
+    updateDimensionOperation: (state: VaultConfigState, action: UpdateDimensionAction, dispatch?: SignalDispatch) => void;
+    updateVocabularyOperation: (state: VaultConfigState, action: UpdateVocabularyAction, dispatch?: SignalDispatch) => void;
+    updatePipelineConfigOperation: (state: VaultConfigState, action: UpdatePipelineConfigAction, dispatch?: SignalDispatch) => void;
+    updateMaintenanceThresholdOperation: (state: VaultConfigState, action: UpdateMaintenanceThresholdAction, dispatch?: SignalDispatch) => void;
+    addExtractionCategoryOperation: (state: VaultConfigState, action: AddExtractionCategoryAction, dispatch?: SignalDispatch) => void;
+    toggleExtractionCategoryOperation: (state: VaultConfigState, action: ToggleExtractionCategoryAction, dispatch?: SignalDispatch) => void;
+    toggleFeatureOperation: (state: VaultConfigState, action: ToggleFeatureAction, dispatch?: SignalDispatch) => void;
+}
+//# sourceMappingURL=operations.d.ts.map

package/dist/document-models/vault-config/v1/gen/config-management/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../../../document-models/vault-config/v1/gen/config-management/operations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,gCAAgC,EAChC,2BAA2B,EAC3B,8BAA8B,EAC9B,mBAAmB,EACpB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,MAAM,WAAW,qCAAqC;IACpD,yBAAyB,EAAE,CACzB,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,sBAAsB,EAC9B,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,wBAAwB,EAAE,CACxB,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,qBAAqB,EAC7B,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,yBAAyB,EAAE,CACzB,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,sBAAsB,EAC9B,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,6BAA6B,EAAE,CAC7B,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,0BAA0B,EAClC,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,mCAAmC,EAAE,CACnC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,gCAAgC,EACxC,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,8BAA8B,EAAE,CAC9B,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,2BAA2B,EACnC,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,iCAAiC,EAAE,CACjC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,8BAA8B,EACtC,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;IACV,sBAAsB,EAAE,CACtB,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,CAAC,EAAE,cAAc,KACtB,IAAI,CAAC;CACX"}

package/dist/document-models/vault-config/v1/gen/config-management/operations.js

@@ -0,0 +1 @@
+import {} from "document-model";

package/dist/document-models/vault-config/v1/gen/controller.d.ts

@@ -0,0 +1,4 @@
+import { PHDocumentController } from "document-model/core";
+import type { VaultConfigPHState } from "./types.js";
+export declare const VaultConfigController: new (initialDocument?: import("document-model").PHDocument<VaultConfigPHState> | undefined) => PHDocumentController<VaultConfigPHState> & import("document-model/core").ActionMap<import("./actions.js").VaultConfigConfigManagementAction, PHDocumentController<VaultConfigPHState>>;
+//# sourceMappingURL=controller.d.ts.map

package/dist/document-models/vault-config/v1/gen/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAExE,eAAO,MAAM,qBAAqB,uRAGpB,CAAC"}

package/dist/document-models/vault-config/v1/gen/controller.js

@@ -0,0 +1,3 @@
+import { PHDocumentController } from "document-model/core";
+import { VaultConfig } from "../module.js";
+export const VaultConfigController = PHDocumentController.forDocumentModel(VaultConfig);

package/dist/document-models/vault-config/v1/gen/creators.d.ts

@@ -0,0 +1,3 @@
+export * from "./config-management/creators.js";
+export * as configManagementActions from "./config-management/creators.js";
+//# sourceMappingURL=creators.d.ts.map

package/dist/document-models/vault-config/v1/gen/creators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"creators.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/creators.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,OAAO,KAAK,uBAAuB,MAAM,iCAAiC,CAAC"}

package/dist/document-models/vault-config/v1/gen/creators.js

@@ -0,0 +1,2 @@
+export * from "./config-management/creators.js";
+export * as configManagementActions from "./config-management/creators.js";

package/dist/document-models/vault-config/v1/gen/document-model.d.ts

@@ -0,0 +1,3 @@
+import type { DocumentModelGlobalState } from "document-model";
+export declare const documentModel: DocumentModelGlobalState;
+//# sourceMappingURL=document-model.d.ts.map

package/dist/document-models/vault-config/v1/gen/document-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-model.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/document-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE/D,eAAO,MAAM,aAAa,EAAE,wBAgJ3B,CAAC"}

package/dist/document-models/vault-config/v1/gen/document-model.js

@@ -0,0 +1,125 @@
+export const documentModel = {
+    id: "bai/vault-config",
+    name: "VaultConfig",
+    author: {
+        name: "BAI",
+        website: "https://bai.dev",
+    },
+    extension: "vcfg.phd",
+    description: "Live vault configuration \u2014 singleton document controlling the 8-dimension parameter space, vocabulary mapping, pipeline settings, and maintenance thresholds.",
+    specifications: [
+        {
+            state: {
+                local: {
+                    schema: "",
+                    examples: [],
+                    initialValue: "",
+                },
+                global: {
+                    schema: "type DimensionPosition {\n    value: Int!\n    confidence: Float!\n    rationale: String\n}\n\ntype DimensionConfig {\n    granularity: DimensionPosition!\n    organization: DimensionPosition!\n    linking: DimensionPosition!\n    processing: DimensionPosition!\n    navigation: DimensionPosition!\n    maintenance: DimensionPosition!\n    schema: DimensionPosition!\n    automation: DimensionPosition!\n}\n\ntype VocabularyMap {\n    notes: String!\n    inbox: String!\n    reduce: String!\n    reflect: String!\n    reweave: String!\n    verify: String!\n    rethink: String!\n    topicMap: String!\n    description: String!\n}\n\ntype PipelineConfig {\n    depth: String!\n    autoChain: Boolean!\n    extractionSelectivity: Float!\n}\n\ntype MaintenanceConfig {\n    orphanThreshold: Int!\n    danglingThreshold: Int!\n    inboxPressure: Int!\n    observationAccumulation: Int!\n    tensionAccumulation: Int!\n    mocOversize: Int!\n    staleNoteDays: Int!\n}\n\ntype ExtractionCategory {\n    id: OID!\n    name: String!\n    description: String!\n    active: Boolean!\n}\n\ntype NoteSchemaConfig {\n    requiredFields: [String!]!\n    optionalFields: [String!]!\n    kindValues: [String!]!\n    confidenceValues: [String!]!\n}\n\ntype MocSchemaConfig {\n    requiredFields: [String!]!\n    tierValues: [String!]!\n}\n\ntype VaultConfigState {\n    name: String\n    domain: String\n    dimensions: DimensionConfig\n    vocabulary: VocabularyMap\n    features: [String!]!\n    pipeline: PipelineConfig\n    maintenance: MaintenanceConfig\n    extractionCategories: [ExtractionCategory!]!\n    noteSchema: NoteSchemaConfig\n    mocSchema: MocSchemaConfig\n    updatedAt: DateTime\n}",
+                    examples: [],
+                    initialValue: '{\n    "name": null,\n    "domain": null,\n    "dimensions": null,\n    "vocabulary": null,\n    "features": [],\n    "pipeline": null,\n    "maintenance": null,\n    "extractionCategories": [],\n    "noteSchema": null,\n    "mocSchema": null,\n    "updatedAt": null\n}',
+                },
+            },
+            modules: [
+                {
+                    id: "config-management",
+                    name: "config-management",
+                    description: "Vault configuration lifecycle",
+                    operations: [
+                        {
+                            id: "initialize-config",
+                            name: "INITIALIZE_CONFIG",
+                            description: "Initialize vault configuration with name and domain",
+                            schema: "input InitializeConfigInput {\n    name: String!\n    domain: String!\n    updatedAt: DateTime!\n}",
+                            template: "Initialize vault configuration with name and domain",
+                            reducer: "state.name = action.input.name;\nstate.domain = action.input.domain;\nstate.updatedAt = action.input.updatedAt;",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "update-dimension",
+                            name: "UPDATE_DIMENSION",
+                            description: "Update a dimension position",
+                            schema: "input UpdateDimensionInput {\n    dimension: String!\n    value: Int!\n    confidence: Float!\n    rationale: String\n    updatedAt: DateTime!\n}",
+                            template: "Update a dimension position",
+                            reducer: "if (!state.dimensions) state.dimensions = {\n    granularity: { value: 3, confidence: 0.5, rationale: null },\n    organization: { value: 3, confidence: 0.5, rationale: null },\n    linking: { value: 3, confidence: 0.5, rationale: null },\n    processing: { value: 3, confidence: 0.5, rationale: null },\n    navigation: { value: 3, confidence: 0.5, rationale: null },\n    maintenance: { value: 3, confidence: 0.5, rationale: null },\n    schema: { value: 3, confidence: 0.5, rationale: null },\n    automation: { value: 3, confidence: 0.5, rationale: null },\n};\nconst dim = action.input.dimension;\nif (dim in state.dimensions) {\n    (state.dimensions as any)[dim] = {\n        value: action.input.value,\n        confidence: action.input.confidence,\n        rationale: action.input.rationale || null,\n    };\n}\nstate.updatedAt = action.input.updatedAt;",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "update-vocabulary",
+                            name: "UPDATE_VOCABULARY",
+                            description: "Update a vocabulary term",
+                            schema: "input UpdateVocabularyInput {\n    key: String!\n    value: String!\n    updatedAt: DateTime!\n}",
+                            template: "Update a vocabulary term",
+                            reducer: 'if (!state.vocabulary) state.vocabulary = {\n    notes: "notes", inbox: "inbox", reduce: "reduce", reflect: "reflect",\n    reweave: "reweave", verify: "verify", rethink: "rethink",\n    topicMap: "topic map", description: "description",\n};\nif (action.input.key in state.vocabulary) {\n    (state.vocabulary as any)[action.input.key] = action.input.value;\n}\nstate.updatedAt = action.input.updatedAt;',
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "update-pipeline-config",
+                            name: "UPDATE_PIPELINE_CONFIG",
+                            description: "Update pipeline settings",
+                            schema: "input UpdatePipelineConfigInput {\n    depth: String\n    autoChain: Boolean\n    extractionSelectivity: Float\n    updatedAt: DateTime!\n}",
+                            template: "Update pipeline settings",
+                            reducer: 'if (!state.pipeline) state.pipeline = { depth: "standard", autoChain: false, extractionSelectivity: 0.1 };\nif (action.input.depth) state.pipeline.depth = action.input.depth;\nif (action.input.autoChain !== undefined && action.input.autoChain !== null) state.pipeline.autoChain = action.input.autoChain;\nif (action.input.extractionSelectivity !== undefined && action.input.extractionSelectivity !== null) state.pipeline.extractionSelectivity = action.input.extractionSelectivity;\nstate.updatedAt = action.input.updatedAt;',
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "update-maintenance-threshold",
+                            name: "UPDATE_MAINTENANCE_THRESHOLD",
+                            description: "Update a maintenance threshold",
+                            schema: "input UpdateMaintenanceThresholdInput {\n    condition: String!\n    threshold: Int!\n    updatedAt: DateTime!\n}",
+                            template: "Update a maintenance threshold",
+                            reducer: "if (!state.maintenance) state.maintenance = {\n    orphanThreshold: 1, danglingThreshold: 1, inboxPressure: 5,\n    observationAccumulation: 10, tensionAccumulation: 5, mocOversize: 40, staleNoteDays: 30,\n};\nif (action.input.condition in state.maintenance) {\n    (state.maintenance as any)[action.input.condition] = action.input.threshold;\n}\nstate.updatedAt = action.input.updatedAt;",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "add-extraction-category",
+                            name: "ADD_EXTRACTION_CATEGORY",
+                            description: "Add an extraction category",
+                            schema: "input AddExtractionCategoryInput {\n    id: OID!\n    name: String!\n    description: String!\n    active: Boolean!\n}",
+                            template: "Add an extraction category",
+                            reducer: "state.extractionCategories.push({\n    id: action.input.id,\n    name: action.input.name,\n    description: action.input.description,\n    active: action.input.active,\n});",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "toggle-extraction-category",
+                            name: "TOGGLE_EXTRACTION_CATEGORY",
+                            description: "Enable/disable an extraction category",
+                            schema: "input ToggleExtractionCategoryInput {\n    id: OID!\n    active: Boolean!\n}",
+                            template: "Enable/disable an extraction category",
+                            reducer: "const cat = state.extractionCategories.find(c => c.id === action.input.id);\nif (cat) cat.active = action.input.active;",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "toggle-feature",
+                            name: "TOGGLE_FEATURE",
+                            description: "Enable/disable a feature block",
+                            schema: "input ToggleFeatureInput {\n    feature: String!\n    enabled: Boolean!\n}",
+                            template: "Enable/disable a feature block",
+                            reducer: "if (action.input.enabled && !state.features.includes(action.input.feature)) {\n    state.features.push(action.input.feature);\n} else if (!action.input.enabled) {\n    state.features = state.features.filter(f => f !== action.input.feature);\n}",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+            ],
+            version: 1,
+            changeLog: [],
+        },
+    ],
+};

package/dist/document-models/vault-config/v1/gen/document-schema.d.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import type { VaultConfigDocument, VaultConfigPHState } from "./types.js";
+/** Schema for validating the header object of a VaultConfig document */
+export declare const VaultConfigDocumentHeaderSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAtUtcIso: z.ZodString;
+    lastModifiedAtUtcIso: z.ZodString;
+    documentType: z.ZodLiteral<"bai/vault-config">;
+}, z.core.$strip>;
+/** Schema for validating the state object of a VaultConfig document */
+export declare const VaultConfigPHStateSchema: z.ZodObject<{
+    global: z.ZodObject<Required<{
+        dimensions: z.ZodType<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown>>;
+        domain: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        extractionCategories: z.ZodType<import("./types.js").ExtractionCategory[], unknown, z.core.$ZodTypeInternals<import("./types.js").ExtractionCategory[], unknown>>;
+        features: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        maintenance: z.ZodType<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown>>;
+        mocSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown>>;
+        name: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        noteSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown>>;
+        pipeline: z.ZodType<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown>>;
+        updatedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        vocabulary: z.ZodType<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown>>;
+    }>, z.core.$strip>;
+}, z.core.$strip>;
+export declare const VaultConfigDocumentSchema: z.ZodObject<{
+    header: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        createdAtUtcIso: z.ZodString;
+        lastModifiedAtUtcIso: z.ZodString;
+        documentType: z.ZodLiteral<"bai/vault-config">;
+    }, z.core.$strip>;
+    state: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            dimensions: z.ZodType<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown>>;
+            domain: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            extractionCategories: z.ZodType<import("./types.js").ExtractionCategory[], unknown, z.core.$ZodTypeInternals<import("./types.js").ExtractionCategory[], unknown>>;
+            features: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            maintenance: z.ZodType<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown>>;
+            mocSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown>>;
+            name: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            noteSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown>>;
+            pipeline: z.ZodType<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown>>;
+            updatedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            vocabulary: z.ZodType<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+    initialState: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            dimensions: z.ZodType<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").DimensionConfig>, unknown>>;
+            domain: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            extractionCategories: z.ZodType<import("./types.js").ExtractionCategory[], unknown, z.core.$ZodTypeInternals<import("./types.js").ExtractionCategory[], unknown>>;
+            features: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            maintenance: z.ZodType<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MaintenanceConfig>, unknown>>;
+            mocSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").MocSchemaConfig>, unknown>>;
+            name: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            noteSchema: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteSchemaConfig>, unknown>>;
+            pipeline: z.ZodType<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").PipelineConfig>, unknown>>;
+            updatedAt: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            vocabulary: z.ZodType<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").VocabularyMap>, unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Simple helper function to check if a state object is a VaultConfig document state object */
+export declare function isVaultConfigState(state: unknown): state is VaultConfigPHState;
+/** Simple helper function to assert that a document state object is a VaultConfig document state object */
+export declare function assertIsVaultConfigState(state: unknown): asserts state is VaultConfigPHState;
+/** Simple helper function to check if a document is a VaultConfig document */
+export declare function isVaultConfigDocument(document: unknown): document is VaultConfigDocument;
+/** Simple helper function to assert that a document is a VaultConfig document */
+export declare function assertIsVaultConfigDocument(document: unknown): asserts document is VaultConfigDocument;
+//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/vault-config/v1/gen/document-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE1E,wEAAwE;AACxE,eAAO,MAAM,+BAA+B;;;;;;iBAE1C,CAAC;AAEH,uEAAuE;AACvE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;iBAEnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIpC,CAAC;AAEH,+FAA+F;AAC/F,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,kBAAkB,CAE7B;AAED,2GAA2G;AAC3G,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,kBAAkB,CAErC;AAED,8EAA8E;AAC9E,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,mBAAmB,CAEjC;AAED,iFAAiF;AACjF,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,mBAAmB,CAEzC"}

package/dist/document-models/vault-config/v1/gen/document-schema.js

@@ -0,0 +1,33 @@
+import { BaseDocumentHeaderSchema, BaseDocumentStateSchema, } from "document-model";
+import { z } from "zod";
+import { vaultConfigDocumentType } from "./document-type.js";
+import { VaultConfigStateSchema } from "./schema/zod.js";
+/** Schema for validating the header object of a VaultConfig document */
+export const VaultConfigDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({
+    documentType: z.literal(vaultConfigDocumentType),
+});
+/** Schema for validating the state object of a VaultConfig document */
+export const VaultConfigPHStateSchema = BaseDocumentStateSchema.extend({
+    global: VaultConfigStateSchema(),
+});
+export const VaultConfigDocumentSchema = z.object({
+    header: VaultConfigDocumentHeaderSchema,
+    state: VaultConfigPHStateSchema,
+    initialState: VaultConfigPHStateSchema,
+});
+/** Simple helper function to check if a state object is a VaultConfig document state object */
+export function isVaultConfigState(state) {
+    return VaultConfigPHStateSchema.safeParse(state).success;
+}
+/** Simple helper function to assert that a document state object is a VaultConfig document state object */
+export function assertIsVaultConfigState(state) {
+    VaultConfigPHStateSchema.parse(state);
+}
+/** Simple helper function to check if a document is a VaultConfig document */
+export function isVaultConfigDocument(document) {
+    return VaultConfigDocumentSchema.safeParse(document).success;
+}
+/** Simple helper function to assert that a document is a VaultConfig document */
+export function assertIsVaultConfigDocument(document) {
+    VaultConfigDocumentSchema.parse(document);
+}

package/dist/document-models/vault-config/v1/gen/document-type.d.ts

@@ -0,0 +1,2 @@
+export declare const vaultConfigDocumentType = "bai/vault-config";
+//# sourceMappingURL=document-type.d.ts.map

package/dist/document-models/vault-config/v1/gen/document-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-type.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/document-type.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,qBAAqB,CAAC"}

package/dist/document-models/vault-config/v1/gen/document-type.js

@@ -0,0 +1 @@
+export const vaultConfigDocumentType = "bai/vault-config";

package/dist/document-models/vault-config/v1/gen/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./actions.js";
+export * from "./document-model.js";
+export * from "./types.js";
+export * from "./creators.js";
+export { createVaultConfigDocument, createState, defaultPHState, defaultGlobalState, defaultLocalState, } from "./ph-factories.js";
+export * from "./utils.js";
+export * from "./reducer.js";
+export * from "./controller.js";
+export * from "./schema/index.js";
+export * from "./document-type.js";
+export * from "./document-schema.js";
+export * from "./config-management/operations.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/document-models/vault-config/v1/gen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,OAAO,EACL,yBAAyB,EACzB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,mBAAmB,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mCAAmC,CAAC"}

package/dist/document-models/vault-config/v1/gen/index.js

@@ -0,0 +1,12 @@
+export * from "./actions.js";
+export * from "./document-model.js";
+export * from "./types.js";
+export * from "./creators.js";
+export { createVaultConfigDocument, createState, defaultPHState, defaultGlobalState, defaultLocalState, } from "./ph-factories.js";
+export * from "./utils.js";
+export * from "./reducer.js";
+export * from "./controller.js";
+export * from "./schema/index.js";
+export * from "./document-type.js";
+export * from "./document-schema.js";
+export * from "./config-management/operations.js";

package/dist/document-models/vault-config/v1/gen/ph-factories.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Factory methods for creating VaultConfigDocument instances
+ */
+import type { PHAuthState, PHDocumentState, PHBaseState } from "document-model";
+import type { VaultConfigDocument, VaultConfigLocalState, VaultConfigGlobalState, VaultConfigPHState } from "./types.js";
+export declare function defaultGlobalState(): VaultConfigGlobalState;
+export declare function defaultLocalState(): VaultConfigLocalState;
+export declare function defaultPHState(): VaultConfigPHState;
+export declare function createGlobalState(state?: Partial<VaultConfigGlobalState>): VaultConfigGlobalState;
+export declare function createLocalState(state?: Partial<VaultConfigLocalState>): VaultConfigLocalState;
+export declare function createState(baseState?: Partial<PHBaseState>, globalState?: Partial<VaultConfigGlobalState>, localState?: Partial<VaultConfigLocalState>): VaultConfigPHState;
+/**
+ * Creates a VaultConfigDocument with custom global and local state
+ * This properly handles the PHBaseState requirements while allowing
+ * document-specific state to be set.
+ */
+export declare function createVaultConfigDocument(state?: Partial<{
+    auth?: Partial<PHAuthState>;
+    document?: Partial<PHDocumentState>;
+    global?: Partial<VaultConfigGlobalState>;
+    local?: Partial<VaultConfigLocalState>;
+}>): VaultConfigDocument;
+//# sourceMappingURL=ph-factories.d.ts.map

package/dist/document-models/vault-config/v1/gen/ph-factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ph-factories.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/ph-factories.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEhF,OAAO,KAAK,EACV,mBAAmB,EACnB,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAGpB,wBAAgB,kBAAkB,IAAI,sBAAsB,CAc3D;AAED,wBAAgB,iBAAiB,IAAI,qBAAqB,CAEzD;AAED,wBAAgB,cAAc,IAAI,kBAAkB,CAMnD;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,GACtC,sBAAsB,CAKxB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACrC,qBAAqB,CAKvB;AAED,wBAAgB,WAAW,CACzB,SAAS,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EAChC,WAAW,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,EAC7C,UAAU,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAC1C,kBAAkB,CAMpB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5B,QAAQ,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACzC,KAAK,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,CAAC;CACxC,CAAC,GACD,mBAAmB,CAYrB"}

package/dist/document-models/vault-config/v1/gen/ph-factories.js

@@ -0,0 +1,57 @@
+import { createBaseState, defaultBaseState } from "document-model/core";
+import { createDocument } from "./utils.js";
+export function defaultGlobalState() {
+    return {
+        name: null,
+        domain: null,
+        dimensions: null,
+        vocabulary: null,
+        features: [],
+        pipeline: null,
+        maintenance: null,
+        extractionCategories: [],
+        noteSchema: null,
+        mocSchema: null,
+        updatedAt: null,
+    };
+}
+export function defaultLocalState() {
+    return {};
+}
+export function defaultPHState() {
+    return {
+        ...defaultBaseState(),
+        global: defaultGlobalState(),
+        local: defaultLocalState(),
+    };
+}
+export function createGlobalState(state) {
+    return {
+        ...defaultGlobalState(),
+        ...(state || {}),
+    };
+}
+export function createLocalState(state) {
+    return {
+        ...defaultLocalState(),
+        ...(state || {}),
+    };
+}
+export function createState(baseState, globalState, localState) {
+    return {
+        ...createBaseState(baseState?.auth, baseState?.document),
+        global: createGlobalState(globalState),
+        local: createLocalState(localState),
+    };
+}
+/**
+ * Creates a VaultConfigDocument with custom global and local state
+ * This properly handles the PHBaseState requirements while allowing
+ * document-specific state to be set.
+ */
+export function createVaultConfigDocument(state) {
+    const document = createDocument(state
+        ? createState(createBaseState(state.auth, state.document), state.global, state.local)
+        : undefined);
+    return document;
+}

package/dist/document-models/vault-config/v1/gen/reducer.d.ts

@@ -0,0 +1,3 @@
+import type { VaultConfigPHState } from "@powerhousedao/knowledge-note/document-models/vault-config/v1";
+export declare const reducer: import("document-model").Reducer<VaultConfigPHState>;
+//# sourceMappingURL=reducer.d.ts.map

package/dist/document-models/vault-config/v1/gen/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../../../../document-models/vault-config/v1/gen/reducer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+DAA+D,CAAC;AA6HxG,eAAO,MAAM,OAAO,sDAAkD,CAAC"}

package/dist/document-models/vault-config/v1/gen/reducer.js

@@ -0,0 +1,53 @@
+import { isDocumentAction, createReducer } from "document-model/core";
+import { vaultConfigConfigManagementOperations } from "../src/reducers/config-management.js";
+import { InitializeConfigInputSchema, UpdateDimensionInputSchema, UpdateVocabularyInputSchema, UpdatePipelineConfigInputSchema, UpdateMaintenanceThresholdInputSchema, AddExtractionCategoryInputSchema, ToggleExtractionCategoryInputSchema, ToggleFeatureInputSchema, } from "./schema/zod.js";
+const stateReducer = (state, action, dispatch) => {
+    if (isDocumentAction(action)) {
+        return state;
+    }
+    switch (action.type) {
+        case "INITIALIZE_CONFIG": {
+            InitializeConfigInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.initializeConfigOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "UPDATE_DIMENSION": {
+            UpdateDimensionInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.updateDimensionOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "UPDATE_VOCABULARY": {
+            UpdateVocabularyInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.updateVocabularyOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "UPDATE_PIPELINE_CONFIG": {
+            UpdatePipelineConfigInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.updatePipelineConfigOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "UPDATE_MAINTENANCE_THRESHOLD": {
+            UpdateMaintenanceThresholdInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.updateMaintenanceThresholdOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "ADD_EXTRACTION_CATEGORY": {
+            AddExtractionCategoryInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.addExtractionCategoryOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "TOGGLE_EXTRACTION_CATEGORY": {
+            ToggleExtractionCategoryInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.toggleExtractionCategoryOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        case "TOGGLE_FEATURE": {
+            ToggleFeatureInputSchema().parse(action.input);
+            vaultConfigConfigManagementOperations.toggleFeatureOperation(state[action.scope], action, dispatch);
+            break;
+        }
+        default:
+            return state;
+    }
+};
+export const reducer = createReducer(stateReducer);