@noodleseed/one 0.161.2 → 0.163.0

package/node_modules/@noodle-borg/cli-catalog/dist/catalog-types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the CLI's declarative command catalog (`catalog.ts`). Pure type definitions — no
+ * runtime code — so this module has zero import cost for anything that only needs the shapes
+ * (including the doc/skill generator scripts, which read the sibling data modules directly).
+ */
+export {};
+//# sourceMappingURL=catalog-types.js.map

package/node_modules/@noodle-borg/cli-catalog/dist/index.js

@@ -0,0 +1,20 @@
+export * from './catalog-data-account.js';
+export * from './catalog-data-assistant.js';
+export * from './catalog-data-auth-discovery.js';
+export * from './catalog-data-billing.js';
+export * from './catalog-data-bootstrap-authoring.js';
+export * from './catalog-data-bootstrap-pre-auth.js';
+export * from './catalog-data-config.js';
+export * from './catalog-data-core.js';
+export * from './catalog-data-distributions.js';
+export * from './catalog-data-hosted-deployment.js';
+export * from './catalog-data-hosted-governance.js';
+export * from './catalog-data-hosted-observability.js';
+export * from './catalog-data-local-authoring.js';
+export * from './catalog-data-platform-auth.js';
+export * from './catalog-data-policy.js';
+export * from './catalog-data-solutions.js';
+export * from './catalog-data-tenant-admin.js';
+export * from './catalog-data-tenant-resources.js';
+export * from './catalog-types.js';
+//# sourceMappingURL=index.js.map

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, variables, }) {
     // 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,10 @@ export function assembleRuntimeArtifact({ manifest, options, runtimeBranding, ru
                 : {}),
             ...(manifest.server.auth !== undefined ? { auth: manifest.server.auth } : {}),
             ...(knowledge !== undefined && knowledge.length > 0 ? { knowledge } : {}),
+            ...(variables !== undefined && variables.length > 0 ? { variables } : {}),
+            ...(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/catalog-emission.js

@@ -5,7 +5,9 @@ import { requiresToolConfirmation } from './consent.js';
 /** Resolve connector references and emit catalog-dependent artifact surfaces. */
 export function emitCatalogArtifactSurfaces({ manifest, catalog, structuralAmbientContext, structuralTools, structuralResources, structuralPrompts, toolUiMetaByName, errors, }) {
     const declared = manifest.connectors ?? {};
-    const usedAliases = new Set();
+    const usedAliases = new Set(manifest.manifestVersion === '2'
+        ? (manifest.server.collections ?? []).flatMap((collection) => collection.source === undefined ? [] : [collection.source.connector])
+        : []);
     const customerRouting = catalog === undefined ? undefined : new CustomerRoutingCollector(manifest.server.auth, errors);
     const artifactAmbientContext = emitAmbientContext(structuralAmbientContext, catalog, declared, usedAliases, errors, customerRouting);
     const artifactTools = structuralTools.map((s) => {

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

@@ -1,5 +1,8 @@
 export function artifactConfig(manifest, tools, resources, prompts, connectorBindings, ambientFulfilment) {
     const variables = new Set();
+    if (manifest.manifestVersion === '2')
+        for (const declaration of manifest.server.variables ?? [])
+            variables.add(declaration.name);
     collectVariablesFromManagedOrigins(manifest, variables);
     for (const tool of tools)
         collectVariablesFromFulfilment(tool.fulfilment, variables);

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

@@ -1,6 +1,8 @@
 import type { CapabilityRequirementName } from '@noodle-borg/capabilities';
 import type { CompiledKnowledgeComponent } from '@noodle-borg/knowledge/portable';
+import type { ArtifactVariableDeclaration } from '../business-variables.js';
 import type { CustomerEndpointPolicy } from '../customer-endpoint.js';
+import type { ManagedCollectionControls } from '../managed-collection-controls.js';
 import type { CondNode, ExprNode } from '../manifest/expression.js';
 import type { Manifest } from '../manifest/schema.js';
 import type { OperationRef } from './operation-ref.js';
@@ -165,6 +167,26 @@ export interface ArtifactServerContext {
         readonly fulfilment: ArtifactFulfilment;
     };
 }
+export interface ArtifactManagedCollection extends ManagedCollectionControls {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly schemaVersion: number;
+    readonly schemaDigest: string;
+    readonly recordSchema: JsonSchema;
+    readonly behavior?: {
+        readonly kind: 'request';
+    };
+    readonly source: {
+        readonly authority: 'native';
+    } | {
+        readonly authority: 'external';
+        readonly connectorAlias: string;
+        readonly connectorId: string;
+        readonly connectorVersion: string;
+        readonly scan: OperationRef;
+    };
+}
 interface ArtifactOidcAuth {
     readonly kind?: 'oidc' | undefined;
     readonly issuer: string;
@@ -227,6 +249,10 @@ 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[];
+    /** Typed reusable managed-variable declarations, never live operator values. */
+    readonly variables?: readonly ArtifactVariableDeclaration[];
     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,16 @@
  *
  * `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.
+ *
+ * `0.18.0` (Collection authority): additive — every newly compiled managed collection identifies native
+ * authority or exact resolved read-only connector operations for an external replica.
+ *
+ * `0.19.0` (Business settings): optional typed managed-variable declarations and definition digests.
  */
-export declare const ARTIFACT_SCHEMA_VERSION = "0.16.0";
+export declare const ARTIFACT_SCHEMA_VERSION = "0.19.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,16 @@
  *
  * `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.
+ *
+ * `0.18.0` (Collection authority): additive — every newly compiled managed collection identifies native
+ * authority or exact resolved read-only connector operations for an external replica.
+ *
+ * `0.19.0` (Business settings): optional typed managed-variable declarations and definition digests.
  */
-export const ARTIFACT_SCHEMA_VERSION = '0.16.0';
+export const ARTIFACT_SCHEMA_VERSION = '0.19.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/business-variables.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { CompileError } from './errors.js';
+export declare const MAX_VARIABLE_DECLARATIONS = 64;
+export declare const MAX_VARIABLE_SCHEMA_BYTES: number;
+export declare const MAX_VARIABLE_VALUE_BYTES: number;
+export declare const MAX_VARIABLE_SCHEMA_DEPTH = 6;
+export declare const variableDeclarationManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+    valueSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    portal: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        help: z.ZodOptional<z.ZodString>;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    requiredFor: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type VariableDeclarationManifest = z.infer<typeof variableDeclarationManifestSchema>;
+export interface ArtifactVariableDeclaration extends VariableDeclarationManifest {
+    /** Hash of the complete declaration; metadata, default and capability changes are revision-visible. */
+    readonly schemaDigest: string;
+}
+/** The one declaration validator used by TypeScript authoring, compilation and activation. */
+export declare function validateVariableDeclaration(declaration: VariableDeclarationManifest): readonly CompileError[];
+export declare function compileVariableDeclarations(declarations: readonly VariableDeclarationManifest[], toolNames: readonly string[], errors: CompileError[]): readonly ArtifactVariableDeclaration[];
+//# sourceMappingURL=business-variables.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/business-variables.js

@@ -0,0 +1,230 @@
+import { canonicalJson, sensitiveContentFinding, sha256Canonical, validateJsonSchema, } from '@noodle-borg/app-package';
+import { z } from 'zod';
+export const MAX_VARIABLE_DECLARATIONS = 64;
+export const MAX_VARIABLE_SCHEMA_BYTES = 16 * 1024;
+export const MAX_VARIABLE_VALUE_BYTES = 16 * 1024;
+export const MAX_VARIABLE_SCHEMA_DEPTH = 6;
+const plainText = (max) => z
+    .string()
+    .trim()
+    .min(1)
+    .max(max)
+    .regex(/^[^<>\p{Cc}]+$/u, 'must be plain text without markup or control characters');
+export const variableDeclarationManifestSchema = z
+    .object({
+    name: z
+        .string()
+        .min(1)
+        .max(128)
+        .regex(/^(?!(?:__proto__|prototype|constructor)$)[A-Za-z0-9_]+$/),
+    schemaVersion: z.literal(1),
+    valueSchema: z.record(z.string(), z.unknown()),
+    default: z.unknown().optional(),
+    portal: z
+        .object({
+        label: plainText(120),
+        help: plainText(1000).optional(),
+        group: plainText(80).optional(),
+    })
+        .strict()
+        .optional(),
+    requiredFor: z.array(z.string().regex(/^[a-z][a-z0-9_]*$/)).max(128),
+})
+    .strict();
+/** The one declaration validator used by TypeScript authoring, compilation and activation. */
+export function validateVariableDeclaration(declaration) {
+    const errors = [];
+    const parsed = variableDeclarationManifestSchema.safeParse(declaration);
+    if (!parsed.success)
+        return [
+            {
+                code: 'invalid_variable_declaration',
+                path: '',
+                message: 'invalid variable declaration metadata or version',
+            },
+        ];
+    const fail = (path, message) => errors.push({ code: 'invalid_variable_declaration', path, message });
+    if (!isBoundedJson(declaration.valueSchema, MAX_VARIABLE_SCHEMA_BYTES)) {
+        fail('valueSchema', 'value schema must be bounded JSON');
+        return errors;
+    }
+    validateValueSchema(declaration.valueSchema, 'valueSchema', 0, { fields: 0 }, fail);
+    if (errors.length > 0)
+        return errors;
+    const schemaIssues = validateJsonSchema(declaration.valueSchema, undefined);
+    if (schemaIssues.some((issue) => issue.keyword === 'schema'))
+        fail('valueSchema', 'invalid JSON Schema');
+    if (Object.hasOwn(declaration, 'default')) {
+        if (!isBoundedJson(declaration.default, MAX_VARIABLE_VALUE_BYTES))
+            fail('default', 'default must be bounded JSON');
+        else if (validateJsonSchema(declaration.valueSchema, declaration.default).length > 0)
+            fail('default', 'default does not match the declared value schema');
+    }
+    if (sensitiveContentFinding({ portal: declaration.portal, default: declaration.default }) !==
+        undefined) {
+        fail('', 'variable metadata/default must not contain credentials');
+    }
+    return errors;
+}
+export function compileVariableDeclarations(declarations, toolNames, errors) {
+    const seen = new Map();
+    for (const [index, declaration] of declarations.entries()) {
+        const path = `server.variables.${index}`;
+        const issues = validateVariableDeclaration(declaration);
+        if (issues.length > 0) {
+            errors.push(...issues.map((issue) => ({ ...issue, path: issue.path ? `${path}.${issue.path}` : path })));
+            continue;
+        }
+        const normalized = {
+            ...declaration,
+            requiredFor: [...new Set(declaration.requiredFor)].sort(),
+        };
+        const schemaDigest = sha256Canonical(normalized);
+        const previous = seen.get(declaration.name);
+        if (previous !== undefined && previous.schemaDigest !== schemaDigest) {
+            errors.push({
+                code: 'invalid_variable_declaration',
+                path,
+                message: 'conflicting duplicate variable declaration',
+            });
+            continue;
+        }
+        for (const name of normalized.requiredFor) {
+            if (!toolNames.includes(name))
+                errors.push({
+                    code: 'invalid_variable_declaration',
+                    path: `${path}.requiredFor`,
+                    message: `required capability "${name}" is not a declared tool`,
+                });
+        }
+        seen.set(declaration.name, { ...normalized, schemaDigest });
+    }
+    return [...seen.values()].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+const commonKeys = ['$schema', 'type', 'title', 'description'];
+const typeKeys = {
+    string: ['minLength', 'maxLength', 'enum', 'format'],
+    boolean: [],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    integer: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'],
+    array: ['items', 'minItems', 'maxItems', 'uniqueItems'],
+    object: ['properties', 'required', 'additionalProperties'],
+};
+function validateValueSchema(schema, path, depth, count, fail) {
+    if (depth > MAX_VARIABLE_SCHEMA_DEPTH) {
+        fail(path, 'value schema exceeds maximum nesting depth');
+        return;
+    }
+    const type = schema.type;
+    if (typeof type !== 'string' || !Object.hasOwn(typeKeys, type)) {
+        fail(path, 'unsupported setting value type');
+        return;
+    }
+    const allowed = new Set([...commonKeys, ...(typeKeys[type] ?? [])]);
+    for (const key of Object.keys(schema))
+        if (!allowed.has(key))
+            fail(`${path}.${key}`, 'unsupported setting schema keyword');
+    for (const key of ['title', 'description']) {
+        if (schema[key] !== undefined && !plainText(1000).safeParse(schema[key]).success)
+            fail(`${path}.${key}`, 'schema metadata must be bounded plain text');
+    }
+    if (schema.$schema !== undefined &&
+        schema.$schema !== 'https://json-schema.org/draft/2020-12/schema')
+        fail(`${path}.$schema`, 'unsupported JSON Schema dialect');
+    if (type === 'string')
+        validateStringSchema(schema, path, fail);
+    if (type === 'number' || type === 'integer') {
+        if (!finiteBound(schema.minimum ?? schema.exclusiveMinimum) ||
+            !finiteBound(schema.maximum ?? schema.exclusiveMaximum))
+            fail(path, 'numbers require finite minimum and maximum');
+        const lower = schema.minimum ?? schema.exclusiveMinimum;
+        const upper = schema.maximum ?? schema.exclusiveMaximum;
+        if (typeof lower === 'number' &&
+            typeof upper === 'number' &&
+            (lower > upper ||
+                (lower === upper &&
+                    (schema.exclusiveMinimum !== undefined || schema.exclusiveMaximum !== undefined))))
+            fail(path, 'numeric bounds must permit at least one value');
+    }
+    if (type === 'array') {
+        if (!boundedCount(schema.maxItems, 100))
+            fail(`${path}.maxItems`, 'arrays require maxItems between 0 and 100');
+        if (typeof schema.minItems === 'number' &&
+            typeof schema.maxItems === 'number' &&
+            schema.minItems > schema.maxItems)
+            fail(path, 'array bounds must permit at least one value');
+        if (!isObject(schema.items))
+            fail(`${path}.items`, 'arrays require one item schema');
+        else
+            validateValueSchema(schema.items, `${path}.items`, depth + 1, count, fail);
+    }
+    if (type === 'object') {
+        if (schema.additionalProperties !== false)
+            fail(`${path}.additionalProperties`, 'objects must be closed');
+        if (!isObject(schema.properties)) {
+            fail(`${path}.properties`, 'objects require explicit properties');
+            return;
+        }
+        for (const [key, child] of Object.entries(schema.properties)) {
+            count.fields++;
+            if (count.fields > 128) {
+                fail(path, 'value schema exceeds 128 total properties');
+                return;
+            }
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ||
+                ['__proto__', 'prototype', 'constructor'].includes(key))
+                fail(`${path}.properties`, 'unsafe property name');
+            if (!isObject(child))
+                fail(`${path}.properties.${key}`, 'property requires a value schema');
+            else
+                validateValueSchema(child, `${path}.properties.${key}`, depth + 1, count, fail);
+        }
+        if (schema.required !== undefined &&
+            (!Array.isArray(schema.required) ||
+                schema.required.some((key) => typeof key !== 'string' || !Object.hasOwn(schema.properties, key))))
+            fail(`${path}.required`, 'required must name declared properties');
+    }
+}
+function validateStringSchema(schema, path, fail) {
+    if (schema.enum !== undefined) {
+        if (!Array.isArray(schema.enum) ||
+            schema.enum.length === 0 ||
+            schema.enum.length > 100 ||
+            schema.enum.some((item) => typeof item !== 'string' || item.length > 200 || /[\p{Cc}<>]/u.test(item)))
+            fail(`${path}.enum`, 'enums require 1 to 100 bounded plain string choices');
+    }
+    else if (!boundedCount(schema.maxLength, 4096))
+        fail(`${path}.maxLength`, 'strings require maxLength between 0 and 4096');
+    if (schema.format !== undefined &&
+        !['email', 'date', 'date-time', 'time', 'uuid'].includes(String(schema.format)))
+        fail(`${path}.format`, 'unsupported setting string format');
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function boundedCount(value, max) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= max;
+}
+function finiteBound(value) {
+    return (typeof value === 'number' &&
+        Number.isFinite(value) &&
+        Math.abs(value) <= Number.MAX_SAFE_INTEGER);
+}
+function isBoundedJson(value, maxBytes) {
+    try {
+        const rejectUndefined = (node, depth) => {
+            if (node === undefined || depth > 16)
+                return false;
+            if (Array.isArray(node))
+                return Array.from(node).every((child) => rejectUndefined(child, depth + 1));
+            if (node !== null && typeof node === 'object')
+                return Object.values(node).every((child) => rejectUndefined(child, depth + 1));
+            return true;
+        };
+        return rejectUndefined(value, 0) && Buffer.byteLength(canonicalJson(value)) <= maxBytes;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=business-variables.js.map

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

@@ -9,9 +9,11 @@ import { emitCatalogArtifactSurfaces, isContextProvider, } from './artifact/cata
 import { MCP_APP_MIME_TYPE, } from './artifact/types.js';
 import { rewriteHostedAssets, rewriteLocalAssets, } from './assets.js';
 import { brandingWarnings, normalizeRuntimeBranding } from './branding.js';
+import { compileVariableDeclarations } from './business-variables.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 +145,11 @@ 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 variables = compileVariableDeclarations(manifest.manifestVersion === '2' ? (manifest.server.variables ?? []) : [], manifest.tools.map((tool) => tool.name), errors);
+    const managedCollections = compileManagedCollections(manifest.manifestVersion === '2' ? (manifest.server.collections ?? []) : [], manifest.tools.map((tool) => tool.name), errors, {
+        ...(options.catalog === undefined ? {} : { catalog: options.catalog }),
+        declared: manifest.connectors ?? {},
+    });
     const requirements = parseCapabilityRequirements(manifest.requires, errors);
     const seen = new Set();
     const schemasMap = manifest.schemas ?? {};
@@ -434,6 +441,8 @@ export function compileManifest(raw, options = {}) {
         declared,
         customerEndpoints,
         ...(knowledge.length > 0 ? { knowledge } : {}),
+        ...(managedCollections.length > 0 ? { managedCollections } : {}),
+        ...(variables.length > 0 ? { variables } : {}),
     });
     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' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | '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,8 +3,9 @@ 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 { type ArtifactVariableDeclaration, compileVariableDeclarations, MAX_VARIABLE_DECLARATIONS, MAX_VARIABLE_SCHEMA_BYTES, MAX_VARIABLE_SCHEMA_DEPTH, MAX_VARIABLE_VALUE_BYTES, type VariableDeclarationManifest, validateVariableDeclaration, variableDeclarationManifestSchema, } from './business-variables.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
 export { isLegacyFieldMap, normalizeOperationIoSchema } from './catalog/io-schema.js';
 export { computeSignatureHash } from './catalog/signature.js';
@@ -13,6 +14,8 @@ 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 { type ManagedCollectionControls, projectManagedCollectionControls, validateManagedCollectionControls, } from './managed-collection-controls.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';
@@ -20,6 +23,7 @@ export { type Manifest, manifestSchema } from './manifest/schema.js';
 export { type ResolveSchemaResult, resolveSchemaUses, type SchemasMap, } from './manifest/schema-refs.js';
 export { anonymousBehavior } from './manifest/website-projection.js';
 export { type SniffedImage, sniffImageBytes } from './mime-sniffing.js';
+export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';
 export { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES, MAX_TOTAL_WIDGET_HTML_BYTES, RECOMMENDED_COMPILED_WIDGET_HTML_BYTES, } from './widget-limits.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -4,12 +4,15 @@ export { compileAppPackage } from './app-package/compile.js';
 export { isSafeReadTool, requiresToolConfirmation } from './artifact/consent.js';
 export { ARTIFACT_SCHEMA_VERSION, MCP_APP_MIME_TYPE, } from './artifact/types.js';
 export { assetReference, isPackagedAssetReference, localAssetRoutePrefix, prepareLocalAssets, } from './assets.js';
+export { compileVariableDeclarations, MAX_VARIABLE_DECLARATIONS, MAX_VARIABLE_SCHEMA_BYTES, MAX_VARIABLE_SCHEMA_DEPTH, MAX_VARIABLE_VALUE_BYTES, validateVariableDeclaration, variableDeclarationManifestSchema, } from './business-variables.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
 export { isLegacyFieldMap, normalizeOperationIoSchema } from './catalog/io-schema.js';
 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 { projectManagedCollectionControls, validateManagedCollectionControls, } from './managed-collection-controls.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';
@@ -17,6 +20,7 @@ export { manifestSchema } from './manifest/schema.js';
 export { resolveSchemaUses, } from './manifest/schema-refs.js';
 export { anonymousBehavior } from './manifest/website-projection.js';
 export { sniffImageBytes } from './mime-sniffing.js';
+export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';
 export { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES, MAX_TOTAL_WIDGET_HTML_BYTES, RECOMMENDED_COMPILED_WIDGET_HTML_BYTES, } from './widget-limits.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { CompileError } from './errors.js';
+export declare const managedCollectionControlFields: {
+    management: z.ZodOptional<z.ZodObject<{
+        assignment: z.ZodOptional<z.ZodLiteral<true>>;
+        notes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publicFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summaryFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+};
+declare const controlsSchema: z.ZodObject<{
+    management: z.ZodOptional<z.ZodObject<{
+        assignment: z.ZodOptional<z.ZodLiteral<true>>;
+        notes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publicFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summaryFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export interface ManagedCollectionControls {
+    readonly management?: {
+        readonly assignment?: true | undefined;
+        readonly notes?: true | undefined;
+    } | undefined;
+    readonly fields?: Readonly<Record<string, {
+        readonly label?: string | undefined;
+        readonly help?: string | undefined;
+    }>> | undefined;
+    readonly publicFields?: readonly string[] | undefined;
+    readonly editableFields?: readonly string[] | undefined;
+    readonly summaryFields?: readonly string[] | undefined;
+    readonly filterFields?: readonly string[] | undefined;
+    readonly sortFields?: readonly string[] | undefined;
+}
+/** Validate presentation/exposure against actual record fields, independently of application names. */
+export declare function validateManagedCollectionControls(controls: ManagedCollectionControls, schema: Readonly<Record<string, unknown>>, external: boolean, path: string, errors: CompileError[]): void;
+export declare function projectManagedCollectionControls(value: ManagedCollectionControls): z.infer<typeof controlsSchema>;
+export {};
+//# sourceMappingURL=managed-collection-controls.d.ts.map