@noodleseed/one 0.161.2 → 0.162.0

package/node_modules/@noodle-borg/authoring/dist/server.d.ts

@@ -10,6 +10,7 @@ import { type ServerContextOptions } from './context.js';
 import { type CustomerAuth } from './customer-auth.js';
 import { type JsonSchema } from './json-schema.js';
 import { type KnowledgeDeclaration } from './knowledge.js';
+import * as collections from './managed-collection.js';
 import { type ConnectorClient, type SymbolicScope } from './recording.js';
 export type StateHandleKind = 'session' | 'draft' | 'selection' | 'search' | 'cart' | 'workflow';
 export type StateHandleScope = 'deployment' | 'caller';
@@ -50,6 +51,8 @@ export interface ServerOptions {
     readonly assistant?: EmbeddedAssistantConfig;
     /** Customer-owned knowledge components (ADR 0202): compile to generated `search_<name>` capabilities. */
     readonly knowledge?: readonly KnowledgeDeclaration[];
+    /** Typed managed records; operator-owned lifecycle and policy are bound outside reusable source. */
+    readonly collections?: readonly collections.ManagedCollectionDeclaration[];
     readonly branding?: {
         readonly name?: string;
         readonly accent?: string;

package/node_modules/@noodle-borg/authoring/dist/server.js

@@ -10,6 +10,7 @@ import { manifestContext } from './context.js';
 import { manifestCustomerAuth } from './customer-auth.js';
 import { toJsonSchema } from './json-schema.js';
 import { manifestKnowledge } from './knowledge.js';
+import * as collections from './managed-collection.js';
 import { manifestToolAnnotations } from './model-tool-visibility.js';
 import { recordFulfilment, recordTool, } from './recording.js';
 const WIDGET_RESULT_META_KEY = '__noodleResultMeta';
@@ -206,6 +207,7 @@ class ServerBuilder {
                 ...(this.options.knowledge && this.options.knowledge.length > 0
                     ? { knowledge: this.options.knowledge.map(manifestKnowledge) }
                     : {}),
+                ...collections.manifestCollections(this.options.collections),
                 ...(this.options.branding ? { branding: this.options.branding } : {}),
                 ...(this.options.shell ? { shell: manifestShell(this.options.shell) } : {}),
             },

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-data-tenant-resources.js

@@ -76,6 +76,95 @@ const YES = {
     type: 'boolean',
     summary: 'Confirm non-interactively.',
 };
+const RETENTION = {
+    ...OPTIONAL_FLAG,
+    name: 'retention-days',
+    type: 'integer',
+    value: '<days>',
+    summary: 'Managed-record retention in days.',
+    constraints: { choices: [7, 30, 90], default: 30 },
+};
+const INSTALLATION_ARGUMENT = {
+    ...REQUIRED_ARGUMENT,
+    name: 'installation',
+    summary: 'Solution installation identifier.',
+};
+const COLLECTION_ARGUMENT = {
+    ...REQUIRED_ARGUMENT,
+    name: 'collection',
+    summary: 'Managed collection key.',
+};
+const RECORD_ARGUMENT = {
+    ...REQUIRED_ARGUMENT,
+    name: 'record',
+    summary: 'Managed record identifier.',
+};
+const SOLUTION_COMMON_FLAGS = [ORG, SERVICE, AUTH_TOKEN, JSON_FLAG];
+const RECORD_FLAGS = [
+    ...SOLUTION_COMMON_FLAGS,
+    {
+        ...OPTIONAL_FLAG,
+        name: 'data',
+        type: 'string',
+        value: '<json>',
+        summary: 'Structured JSON record data.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'idempotency-key',
+        type: 'string',
+        value: '<key>',
+        summary: 'Retry-safe create key.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'expected-revision',
+        type: 'integer',
+        value: '<revision>',
+        summary: 'Expected current record revision.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'status',
+        type: 'string',
+        value: '<status>',
+        summary: 'Record status or list filter.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'assignee',
+        type: 'string',
+        value: '<subject>',
+        summary: 'Assignee subject or list filter.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'note',
+        type: 'string',
+        value: '<text>',
+        summary: 'Operator note text.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'cursor',
+        type: 'string',
+        value: '<cursor>',
+        summary: 'Opaque page cursor.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'limit',
+        type: 'integer',
+        value: '<count>',
+        summary: 'Bounded page size.',
+    },
+    {
+        ...OPTIONAL_FLAG,
+        name: 'include-deleted',
+        type: 'boolean',
+        summary: 'Include payload-free tombstones.',
+    },
+];
 const WATCH_FLAGS = [
     {
         ...OPTIONAL_FLAG,
@@ -100,6 +189,158 @@ const DEPLOYMENT_BASE_FLAGS = [ORG, APP, ENV, SERVICE, AUTH_TOKEN];
 const DEPLOYMENT_INSPECT_FLAGS = [ORG, SERVICE, AUTH_TOKEN, JSON_FLAG];
 const _GITHUB_BASE_FLAGS = [ORG, APP, SERVICE, AUTH_TOKEN];
 export const CATALOG_TENANT_RESOURCES = [
+    {
+        name: 'solutions',
+        section: 'resources',
+        helpRank: 1,
+        summary: 'Install and operate data-driven business solutions.',
+        arguments: [],
+        flags: [],
+        subcommands: [
+            {
+                name: 'catalog',
+                summary: 'List centrally managed solution profiles.',
+                arguments: [],
+                flags: [SERVICE, AUTH_TOKEN, JSON_FLAG],
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                name: 'list',
+                summary: 'List solution installations for an organization.',
+                arguments: [],
+                flags: SOLUTION_COMMON_FLAGS,
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                name: 'install',
+                summary: 'Install one managed solution profile.',
+                arguments: [{ ...REQUIRED_ARGUMENT, name: 'profile', summary: 'Solution profile key.' }],
+                flags: [...SOLUTION_COMMON_FLAGS, APP, ENV, RETENTION],
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                name: 'inspect',
+                summary: 'Inspect one solution installation.',
+                arguments: [INSTALLATION_ARGUMENT],
+                flags: SOLUTION_COMMON_FLAGS,
+                jsonOutput: { mode: 'single' },
+            },
+            {
+                name: 'grants',
+                summary: 'Manage installation-scoped business grants.',
+                arguments: [],
+                flags: [],
+                subcommands: [
+                    {
+                        name: 'list',
+                        summary: 'List live business grants.',
+                        arguments: [INSTALLATION_ARGUMENT],
+                        flags: SOLUTION_COMMON_FLAGS,
+                        jsonOutput: { mode: 'single' },
+                    },
+                    {
+                        name: 'set',
+                        summary: 'Create or update a business grant.',
+                        arguments: [INSTALLATION_ARGUMENT],
+                        flags: [
+                            ...SOLUTION_COMMON_FLAGS,
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'subject',
+                                type: 'string',
+                                value: '<subject>',
+                                summary: 'Canonical business-user subject.',
+                                required: true,
+                            },
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'email',
+                                type: 'string',
+                                value: '<email>',
+                                summary: 'Business-user email address.',
+                                required: true,
+                            },
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'role',
+                                type: 'string',
+                                value: '<role>',
+                                summary: 'Business role.',
+                                required: true,
+                                constraints: { choices: ['administrator', 'manager', 'operator', 'viewer'] },
+                            },
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'expected-revision',
+                                type: 'integer',
+                                value: '<revision>',
+                                summary: 'Expected current grant revision; 0 for a new grant.',
+                            },
+                        ],
+                        jsonOutput: { mode: 'single' },
+                    },
+                    {
+                        name: 'revoke',
+                        summary: 'Revoke a business grant using optimistic concurrency.',
+                        arguments: [INSTALLATION_ARGUMENT],
+                        flags: [
+                            ...SOLUTION_COMMON_FLAGS,
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'subject',
+                                type: 'string',
+                                value: '<subject>',
+                                summary: 'Canonical business-user subject.',
+                                required: true,
+                            },
+                            {
+                                ...OPTIONAL_FLAG,
+                                name: 'expected-revision',
+                                type: 'integer',
+                                value: '<revision>',
+                                summary: 'Expected current grant revision.',
+                                required: true,
+                            },
+                        ],
+                        jsonOutput: { mode: 'single' },
+                    },
+                ],
+            },
+            {
+                name: 'records',
+                summary: 'Operate one installed managed collection.',
+                arguments: [],
+                flags: [],
+                usage: 'solutions records <list|create|get|update|assign|status|note|activity|delete|export> <installation> <collection> [record] [options]',
+                subcommands: [
+                    ...[
+                        'list',
+                        'create',
+                        'get',
+                        'update',
+                        'assign',
+                        'status',
+                        'note',
+                        'activity',
+                        'delete',
+                        'export',
+                    ].map((name) => ({
+                        name,
+                        summary: `${name[0]?.toUpperCase()}${name.slice(1)} managed records.`,
+                        arguments: [
+                            INSTALLATION_ARGUMENT,
+                            COLLECTION_ARGUMENT,
+                            ...(name === 'list' || name === 'create' || name === 'export'
+                                ? []
+                                : [RECORD_ARGUMENT]),
+                        ],
+                        flags: RECORD_FLAGS,
+                        jsonOutput: { mode: 'single' },
+                    })),
+                ],
+            },
+        ],
+    },
     {
         name: 'apps',
         section: 'resources',

package/node_modules/@noodle-borg/compiler/dist/artifact/assemble.js

@@ -1,6 +1,6 @@
 import { artifactConfig } from './config.js';
 import { ARTIFACT_SCHEMA_VERSION, } from './types.js';
-export function assembleRuntimeArtifact({ manifest, options, runtimeBranding, runtimeShell, artifactAmbientContext, state, artifactTools, allResources, artifactPrompts, packagedAssets, requirements, declared, customerEndpoints, knowledge, }) {
+export function assembleRuntimeArtifact({ manifest, options, runtimeBranding, runtimeShell, artifactAmbientContext, state, artifactTools, allResources, artifactPrompts, packagedAssets, requirements, declared, customerEndpoints, knowledge, managedCollections, }) {
     // 4. Assemble the artifact. `resources`/`prompts` and their capability lists are emitted only when
     // present, keeping a tools-only artifact byte-identical to before this slice.
     const capabilities = {
@@ -40,6 +40,9 @@ export function assembleRuntimeArtifact({ manifest, options, runtimeBranding, ru
                 : {}),
             ...(manifest.server.auth !== undefined ? { auth: manifest.server.auth } : {}),
             ...(knowledge !== undefined && knowledge.length > 0 ? { knowledge } : {}),
+            ...(managedCollections !== undefined && managedCollections.length > 0
+                ? { managedCollections }
+                : {}),
             ...(manifest.server.assistant !== undefined ? { assistant: manifest.server.assistant } : {}),
             ...(runtimeBranding !== undefined ? { branding: runtimeBranding } : {}),
             ...(runtimeShell !== undefined ? { shell: runtimeShell } : {}),

package/node_modules/@noodle-borg/compiler/dist/artifact/types.d.ts

@@ -165,6 +165,14 @@ export interface ArtifactServerContext {
         readonly fulfilment: ArtifactFulfilment;
     };
 }
+export interface ArtifactManagedCollection {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly schemaVersion: number;
+    readonly schemaDigest: string;
+    readonly recordSchema: JsonSchema;
+}
 interface ArtifactOidcAuth {
     readonly kind?: 'oidc' | undefined;
     readonly issuer: string;
@@ -227,6 +235,8 @@ export interface ArtifactServer {
     readonly auth?: ArtifactAuth;
     /** Compiled knowledge components (ADR 0202, Core v2): descriptors + generated tool metadata, never bytes. */
     readonly knowledge?: readonly CompiledKnowledgeComponent[];
+    /** Compiled managed-record schema intent; lifecycle and operator state remain outside artifacts. */
+    readonly managedCollections?: readonly ArtifactManagedCollection[];
     readonly assistant?: {
         readonly model: NonNullable<Manifest['server']['assistant']>['model'];
         readonly allowedOrigins: readonly string[];

package/node_modules/@noodle-borg/compiler/dist/artifact/version.d.ts

@@ -50,8 +50,11 @@
  *
  * `0.16.0` (Anonymous-to-authenticated onboarding): additive — finite caller-scoped state handles may
  * opt into atomic ownership adoption when a single-use assistant sign-in ticket is spent.
+ *
+ * `0.17.0` (Managed collection declaration): additive — Core v2 reusable managed-record schema intent
+ * may be projected under `server.managedCollections`; lifecycle and operator state remain separate.
  */
-export declare const ARTIFACT_SCHEMA_VERSION = "0.16.0";
+export declare const ARTIFACT_SCHEMA_VERSION = "0.17.0";
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export declare const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
 //# sourceMappingURL=version.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/artifact/version.js

@@ -50,8 +50,11 @@
  *
  * `0.16.0` (Anonymous-to-authenticated onboarding): additive — finite caller-scoped state handles may
  * opt into atomic ownership adoption when a single-use assistant sign-in ticket is spent.
+ *
+ * `0.17.0` (Managed collection declaration): additive — Core v2 reusable managed-record schema intent
+ * may be projected under `server.managedCollections`; lifecycle and operator state remain separate.
  */
-export const ARTIFACT_SCHEMA_VERSION = '0.16.0';
+export const ARTIFACT_SCHEMA_VERSION = '0.17.0';
 /** mimeType for an MCP Apps UI resource (SEP-1865). Widgets are served under this profile. */
 export const MCP_APP_MIME_TYPE = 'text/html;profile=mcp-app';
 //# sourceMappingURL=version.js.map

package/node_modules/@noodle-borg/compiler/dist/compile.js

@@ -12,6 +12,7 @@ import { brandingWarnings, normalizeRuntimeBranding } from './branding.js';
 import { validateInteractiveFlow } from './confirmation-flow.js';
 import { parseAmbientContext } from './context-compile.js';
 import { findExternalRef, parseFulfilment } from './fulfilment-structural.js';
+import { compileManagedCollections } from './managed-collections.js';
 import { cspOriginFaults } from './manifest/csp-origins.js';
 import { parseManifestDocument } from './manifest/parse-document.js';
 import { manifestSchema } from './manifest/schema.js';
@@ -143,6 +144,7 @@ export function compileManifest(raw, options = {}) {
     // 2. Structural passes (catalog-independent): duplicate names, `$use` resolution, external refs,
     // fulfilment parsing. `$use` is resolved first so external-ref detection also scans bundled defs.
     const errors = widgetHtmlSizeErrors(manifest, runtimeBranding);
+    const managedCollections = compileManagedCollections(manifest.manifestVersion === '2' ? (manifest.server.collections ?? []) : [], manifest.tools.map((tool) => tool.name), errors);
     const requirements = parseCapabilityRequirements(manifest.requires, errors);
     const seen = new Set();
     const schemasMap = manifest.schemas ?? {};
@@ -434,6 +436,7 @@ export function compileManifest(raw, options = {}) {
         declared,
         customerEndpoints,
         ...(knowledge.length > 0 ? { knowledge } : {}),
+        ...(managedCollections.length > 0 ? { managedCollections } : {}),
     });
     const warnings = [
         ...brandingWarnings(manifest.server.branding),

package/node_modules/@noodle-borg/compiler/dist/errors.d.ts

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/index.d.ts

@@ -3,7 +3,7 @@ export { APP_PACKAGE_V1_VALIDATION_LIMITS, appPackageArtifactV1Schema, canonical
 export { type ParsedUri, type ParseUriResult, parseUriTemplate, type TemplateUri, } from '@noodle-borg/uri-template';
 export { compileAppPackage } from './app-package/compile.js';
 export { isSafeReadTool, requiresToolConfirmation } from './artifact/consent.js';
-export { ARTIFACT_SCHEMA_VERSION, type ArtifactConnectionSource, type ArtifactConnectorBinding, type ArtifactCustomerAuthRouting, type ArtifactFulfilment, type ArtifactMeta, type ArtifactPackagedAsset, type ArtifactPrompt, type ArtifactPromptArgument, type ArtifactResource, type ArtifactServer, type ArtifactServerContext, type ArtifactState, type ArtifactStateHandle, type ArtifactStateHandleKind, type ArtifactStateHandleScope, type ArtifactStep, type ArtifactTool, type ArtifactToolAuthorization, type ExprMap, type JsonSchema, MCP_APP_MIME_TYPE, type OperationRef, type ResolvedCredentialBinding, type ResolvedOperationRef, type RuntimeArtifact, type UnresolvedOperationRef, type WidgetUiMeta, } from './artifact/types.js';
+export { ARTIFACT_SCHEMA_VERSION, type ArtifactConnectionSource, type ArtifactConnectorBinding, type ArtifactCustomerAuthRouting, type ArtifactFulfilment, type ArtifactManagedCollection, type ArtifactMeta, type ArtifactPackagedAsset, type ArtifactPrompt, type ArtifactPromptArgument, type ArtifactResource, type ArtifactServer, type ArtifactServerContext, type ArtifactState, type ArtifactStateHandle, type ArtifactStateHandleKind, type ArtifactStateHandleScope, type ArtifactStep, type ArtifactTool, type ArtifactToolAuthorization, type ExprMap, type JsonSchema, MCP_APP_MIME_TYPE, type OperationRef, type ResolvedCredentialBinding, type ResolvedOperationRef, type RuntimeArtifact, type UnresolvedOperationRef, type WidgetUiMeta, } from './artifact/types.js';
 export { assetReference, type HostedAssetOptions, type HostedPackagedAsset, isPackagedAssetReference, type LocalAssetOptions, localAssetRoutePrefix, type PackagedAsset, type PackagedAssetReference, type PreparedPackagedAsset, prepareLocalAssets, } from './assets.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
 export { isLegacyFieldMap, normalizeOperationIoSchema } from './catalog/io-schema.js';
@@ -13,6 +13,7 @@ export { type CompileOptions, compile, compileManifest, type ValidateResult, val
 export { type CustomerEndpointPolicy, type CustomerEndpointRef, isCustomerEndpointRef, isValidCustomerEndpointName, normalizeCustomerEndpointPolicy, resolveCustomerEndpointBaseUrl, } from './customer-endpoint.js';
 export type { CompileError, CompileErrorCode, CompileResult } from './errors.js';
 export { computeConnectionConfigRevision } from './fulfilment-emit.js';
+export { MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH, MAX_MANAGED_COLLECTION_NAME_LENGTH, MAX_MANAGED_COLLECTION_RECORD_FIELDS, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH, MAX_MANAGED_COLLECTION_SCHEMA_VERSION, MAX_MANAGED_COLLECTION_TITLE_LENGTH, MAX_MANAGED_COLLECTIONS, type ManagedCollectionManifest, } from './managed-collections.js';
 export { type CspFault, type CspList, cspFaultsInManifest, cspOriginFaults, isHonorableCspOrigin, } from './manifest/csp-origins.js';
 export { type ArrayNode, type CoalesceNode, type CondNode, type ExprNode, type ObjectEntry, type ObjectNode, type PathNode, type PathSegment, parseCondition, parseValue, } from './manifest/expression.js';
 export { isValidName, parseOperationRef } from './manifest/naming.js';

package/node_modules/@noodle-borg/compiler/dist/index.js

@@ -10,6 +10,7 @@ export { computeSignatureHash } from './catalog/signature.js';
 export { compile, compileManifest, validateManifest, } from './compile.js';
 export { isCustomerEndpointRef, isValidCustomerEndpointName, normalizeCustomerEndpointPolicy, resolveCustomerEndpointBaseUrl, } from './customer-endpoint.js';
 export { computeConnectionConfigRevision } from './fulfilment-emit.js';
+export { MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH, MAX_MANAGED_COLLECTION_NAME_LENGTH, MAX_MANAGED_COLLECTION_RECORD_FIELDS, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH, MAX_MANAGED_COLLECTION_SCHEMA_VERSION, MAX_MANAGED_COLLECTION_TITLE_LENGTH, MAX_MANAGED_COLLECTIONS, } from './managed-collections.js';
 export { cspFaultsInManifest, cspOriginFaults, isHonorableCspOrigin, } from './manifest/csp-origins.js';
 export { parseCondition, parseValue, } from './manifest/expression.js';
 export { isValidName, parseOperationRef } from './manifest/naming.js';

package/node_modules/@noodle-borg/compiler/dist/managed-collections.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import type { ArtifactManagedCollection } from './artifact/types.js';
+import type { CompileError } from './errors.js';
+export declare const MAX_MANAGED_COLLECTIONS = 16;
+export declare const MAX_MANAGED_COLLECTION_NAME_LENGTH = 64;
+export declare const MAX_MANAGED_COLLECTION_TITLE_LENGTH = 120;
+export declare const MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH = 1000;
+export declare const MAX_MANAGED_COLLECTION_SCHEMA_VERSION = 2147483647;
+export declare const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES: number;
+export declare const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH = 12;
+export declare const MAX_MANAGED_COLLECTION_RECORD_FIELDS = 128;
+export declare const managedCollectionManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    schemaVersion: z.ZodNumber;
+    recordSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type ManagedCollectionManifest = z.infer<typeof managedCollectionManifestSchema>;
+/**
+ * Validate and lower reusable collection intent. Operator lifecycle, grants, residency, and
+ * retention deliberately do not enter this compiled definition.
+ */
+export declare function compileManagedCollections(collections: readonly ManagedCollectionManifest[], toolNames: readonly string[], errors: CompileError[]): readonly ArtifactManagedCollection[];
+//# sourceMappingURL=managed-collections.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/managed-collections.js

@@ -0,0 +1,184 @@
+import { canonicalJson, sha256Canonical } from '@noodle-borg/app-package';
+import { z } from 'zod';
+export const MAX_MANAGED_COLLECTIONS = 16;
+export const MAX_MANAGED_COLLECTION_NAME_LENGTH = 64;
+export const MAX_MANAGED_COLLECTION_TITLE_LENGTH = 120;
+export const MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH = 1_000;
+export const MAX_MANAGED_COLLECTION_SCHEMA_VERSION = 2_147_483_647;
+export const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES = 64 * 1024;
+export const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH = 12;
+export const MAX_MANAGED_COLLECTION_RECORD_FIELDS = 128;
+const collectionNameSchema = z
+    .string()
+    .min(1)
+    .max(MAX_MANAGED_COLLECTION_NAME_LENGTH)
+    .regex(/^[a-z][a-z0-9_]*$/, 'must start with a letter and use lowercase letters, numbers, and underscores');
+const jsonSchemaSchema = z.record(z.string(), z.unknown());
+export const managedCollectionManifestSchema = z
+    .object({
+    name: collectionNameSchema,
+    title: z.string().trim().min(1).max(MAX_MANAGED_COLLECTION_TITLE_LENGTH),
+    description: z.string().trim().min(1).max(MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH),
+    schemaVersion: z.number().int().positive().max(MAX_MANAGED_COLLECTION_SCHEMA_VERSION),
+    recordSchema: jsonSchemaSchema,
+})
+    .strict();
+const PROHIBITED_FIELD_NAME = /(?:card|cvv|cvc|password|passcode|token|secret|passport|governmentid|nationalid|socialsecurity|health|biometric)/i;
+const SUBSCHEMA_MAP_KEYS = [
+    'properties',
+    'patternProperties',
+    '$defs',
+    'dependentSchemas',
+];
+const SUBSCHEMA_KEYS = [
+    'items',
+    'additionalProperties',
+    'propertyNames',
+    'not',
+    'contains',
+    'if',
+    'then',
+    'else',
+];
+const SUBSCHEMA_LIST_KEYS = ['prefixItems', 'allOf', 'anyOf', 'oneOf'];
+/**
+ * Validate and lower reusable collection intent. Operator lifecycle, grants, residency, and
+ * retention deliberately do not enter this compiled definition.
+ */
+export function compileManagedCollections(collections, toolNames, errors) {
+    const compiled = [];
+    const seen = new Set();
+    collections.forEach((collection, index) => {
+        const path = `server.collections.${index}`;
+        if (seen.has(collection.name)) {
+            errors.push({
+                code: 'invalid_managed_collection',
+                path: `${path}.name`,
+                message: `duplicate managed collection name "${collection.name}"`,
+            });
+            return;
+        }
+        seen.add(collection.name);
+        const futureToolName = `submit_${collection.name}`;
+        const collision = toolNames.indexOf(futureToolName);
+        if (collision >= 0) {
+            errors.push({
+                code: 'reserved_name',
+                path: `tools.${collision}.name`,
+                message: `tool name "${futureToolName}" is reserved for managed collection "${collection.name}"`,
+            });
+        }
+        const schemaErrorsBefore = errors.length;
+        validateRecordSchema(collection.recordSchema, `${path}.recordSchema`, errors);
+        if (errors.length !== schemaErrorsBefore)
+            return;
+        compiled.push({
+            name: collection.name,
+            title: collection.title,
+            description: collection.description,
+            schemaVersion: collection.schemaVersion,
+            schemaDigest: sha256Canonical(collection.recordSchema),
+            recordSchema: collection.recordSchema,
+        });
+    });
+    return compiled;
+}
+function validateRecordSchema(schema, path, errors) {
+    const bytes = new TextEncoder().encode(canonicalJson(schema)).byteLength;
+    if (bytes > MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES) {
+        errors.push({
+            code: 'invalid_managed_collection',
+            path,
+            message: `record schema is ${bytes} UTF-8 bytes; the limit is ${MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES} bytes`,
+        });
+        return;
+    }
+    if (schema.type !== 'object' || schema.additionalProperties !== false) {
+        errors.push({
+            code: 'invalid_managed_collection',
+            path,
+            message: 'record schema must be a closed object with additionalProperties false',
+        });
+        return;
+    }
+    const state = { fields: 0, failure: undefined };
+    inspectSchema(schema, path, 1, state);
+    if (state.failure !== undefined)
+        errors.push(state.failure);
+}
+function inspectSchema(node, path, depth, state) {
+    if (state.failure !== undefined ||
+        node === null ||
+        typeof node !== 'object' ||
+        Array.isArray(node)) {
+        return;
+    }
+    if (depth > MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH) {
+        state.failure = {
+            code: 'invalid_managed_collection',
+            path,
+            message: `record schema depth exceeds ${MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH}`,
+        };
+        return;
+    }
+    const schema = node;
+    if (schema.type === 'object' && schema.additionalProperties !== false) {
+        state.failure = {
+            code: 'invalid_managed_collection',
+            path,
+            message: 'every record object must set additionalProperties to false',
+        };
+        return;
+    }
+    const properties = schema.properties;
+    if (isRecord(properties)) {
+        for (const [name, child] of Object.entries(properties)) {
+            state.fields += 1;
+            if (state.fields > MAX_MANAGED_COLLECTION_RECORD_FIELDS) {
+                state.failure = {
+                    code: 'invalid_managed_collection',
+                    path,
+                    message: `record schema declares more than ${MAX_MANAGED_COLLECTION_RECORD_FIELDS} fields`,
+                };
+                return;
+            }
+            if (PROHIBITED_FIELD_NAME.test(name.replace(/[^a-z0-9]/giu, ''))) {
+                state.failure = {
+                    code: 'invalid_managed_collection',
+                    path: `${path}.properties.${name}`,
+                    message: 'managed collection record schemas cannot declare prohibited sensitive fields',
+                };
+                return;
+            }
+            inspectSchema(child, `${path}.properties.${name}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_MAP_KEYS) {
+        if (key === 'properties')
+            continue;
+        const map = schema[key];
+        if (!isRecord(map))
+            continue;
+        for (const [name, child] of Object.entries(map)) {
+            inspectSchema(child, `${path}.${key}.${name}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_KEYS) {
+        const child = schema[key];
+        if (child !== undefined && typeof child !== 'boolean') {
+            inspectSchema(child, `${path}.${key}`, depth + 1, state);
+        }
+    }
+    for (const key of SUBSCHEMA_LIST_KEYS) {
+        const children = schema[key];
+        if (!Array.isArray(children))
+            continue;
+        children.forEach((child, index) => {
+            inspectSchema(child, `${path}.${key}.${index}`, depth + 1, state);
+        });
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=managed-collections.js.map