@noodleseed/one 0.162.0 → 0.164.0

package/node_modules/@noodle-borg/service/dist/business-information/legacy-request-migration.js

@@ -0,0 +1,60 @@
+import { canonicalJson, validateJsonSchema } from '@noodle-borg/compiler';
+import { validateManagedPayload, validateScalar } from './validation.js';
+/** Exact, bounded historical request-bundle conversion; not a generic workflow/status alias. */
+export function isLegacyRequestUpgrade(previous, next) {
+    const properties = next.recordSchema.properties;
+    if (properties === null || typeof properties !== 'object' || Array.isArray(properties))
+        return false;
+    const status = properties.status;
+    if (status === null || typeof status !== 'object' || Array.isArray(status))
+        return false;
+    const oldProperties = previous.recordSchema.properties;
+    return (previous.behavior?.kind === 'request' &&
+        next.behavior === undefined &&
+        next.management?.assignment === true &&
+        next.management.notes === true &&
+        oldProperties !== null &&
+        typeof oldProperties === 'object' &&
+        !Array.isArray(oldProperties) &&
+        !Object.hasOwn(oldProperties, 'status') &&
+        status.type === 'string' &&
+        status.default === 'new' &&
+        canonicalJson(status.enum) ===
+            canonicalJson(['new', 'in_progress', 'resolved', 'closed']) &&
+        !next.publicFields?.includes('status') &&
+        Object.keys(oldProperties).every((field) => next.publicFields?.includes(field)));
+}
+export function migrateLegacyRequestRecord(current, previous, installation, actorSubject, now) {
+    if (current.deletedAt !== undefined || current.content === undefined)
+        return undefined;
+    const next = installation.definition.collections.find((collection) => collection.key === current.collectionKey);
+    if (next === undefined ||
+        next.authority.authority !== 'native' ||
+        previous.authority.authority !== 'native')
+        return undefined;
+    if (current.status === undefined)
+        return current;
+    if (!isLegacyRequestUpgrade(previous, next))
+        return undefined;
+    const payload = validateManagedPayload({ ...current.content.payload, status: current.status });
+    if (validateJsonSchema(next.recordSchema, payload).length > 0)
+        return undefined;
+    const { status: ignoredStatus, ...record } = current;
+    void ignoredStatus;
+    return {
+        ...record,
+        profileVersion: installation.profileVersion,
+        schemaVersion: next.schemaVersion,
+        schemaDigest: next.schemaDigest,
+        originalSchema: current.originalSchema ?? {
+            profileVersion: current.profileVersion,
+            schemaVersion: current.schemaVersion,
+            schemaDigest: current.schemaDigest,
+        },
+        revision: current.revision + 1,
+        updatedAt: now.toISOString(),
+        updatedBySubject: validateScalar('migration actor', actorSubject, 256),
+        content: { payload, notes: structuredClone(current.content.notes) },
+    };
+}
+//# sourceMappingURL=legacy-request-migration.js.map

package/node_modules/@noodle-borg/service/dist/business-information/managed-releases.js

@@ -0,0 +1,245 @@
+import { isLegacyRequestUpgrade } from './legacy-request-migration.js';
+import { managedSolutionBlueprint } from './managed-solution-blueprints.js';
+import { BUILT_IN_SOLUTION_PROFILE_RELEASES, builtInDefinition, builtInDefinitionAtRelease, isBuiltInProfileKey, } from './profiles.js';
+/** Resolves the one service-wide stable release while preserving installation-owned configuration. */
+export function resolveManagedInstallation(installation, resolveCurrent = builtInDefinition) {
+    if (installation.definition.reference.kind !== 'managed')
+        return cloneInstallation(installation);
+    const key = installation.definition.reference.definitionId;
+    const installed = registeredDefinition(key, installation.profileVersion);
+    assertSameDefinition(installed, installation.definition, 'stored installation');
+    const current = resolveCurrent(key);
+    if (current.reference.kind !== 'managed' || current.reference.definitionId !== key) {
+        throw new Error(`managed definition resolver returned the wrong definition for "${key}"`);
+    }
+    const registeredCurrent = registeredDefinition(key, current.reference.release);
+    assertSameDefinition(registeredCurrent, current, 'managed definition resolver');
+    if (current.reference.release < installed.reference.release) {
+        throw new Error(`managed definition rollback "${key}@${current.reference.release}" requires accepted-record compatibility proof`);
+    }
+    for (let release = installed.reference.release + 1; release <= current.reference.release; release += 1) {
+        const previous = registeredDefinition(key, release - 1);
+        const next = registeredDefinition(key, release);
+        assertCompatibleManagedRelease(previous, next);
+    }
+    for (const collection of installation.managedCollections) {
+        if (!current.collections.some((candidate) => candidate.key === collection)) {
+            throw new Error(`managed release removed enabled collection "${collection}"`);
+        }
+    }
+    return cloneInstallation({
+        ...installation,
+        profileVersion: current.reference.release,
+        managedCollections: [...installation.managedCollections],
+        definition: current,
+    });
+}
+/** Resolves the exact validator that accepted a stored row, independently of current presentation. */
+export function collectionForStoredRecord(installation, record) {
+    if (record.scope.org !== installation.scope.org ||
+        record.scope.app !== installation.scope.app ||
+        record.scope.env !== installation.scope.env ||
+        record.scope.installationId !== installation.scope.installationId ||
+        record.profileKey !== installation.profileKey) {
+        throw new Error('stored record does not belong to its solution installation');
+    }
+    let definition;
+    if (installation.definition.reference.kind === 'private') {
+        definition = installation.definition;
+        if (record.profileVersion !== installation.profileVersion) {
+            throw new Error('stored private record uses an unsupported definition version');
+        }
+    }
+    else {
+        if (!isBuiltInProfileKey(record.profileKey)) {
+            throw new Error(`stored record uses unknown profile "${record.profileKey}"`);
+        }
+        definition = builtInDefinitionAtRelease(record.profileKey, record.profileVersion);
+    }
+    const collection = definition.collections.find((candidate) => candidate.key === record.collectionKey);
+    if (collection === undefined ||
+        collection.schemaVersion !== record.schemaVersion ||
+        normalizeDigest(collection.schemaDigest) !== normalizeDigest(record.schemaDigest)) {
+        throw new Error(`stored record uses unsupported schema identity "${record.profileKey}@${record.profileVersion}/${record.collectionKey}@${record.schemaVersion}:${record.schemaDigest}"`);
+    }
+    return structuredClone(collection);
+}
+/** Release-gate proof: a rollback target must retain a validator for every accepted record identity. */
+export function assertManagedRollbackReaders(key, targetRelease, records) {
+    const target = registeredDefinition(key, targetRelease);
+    for (const record of records) {
+        if (record.profileKey !== key)
+            continue;
+        if (record.profileVersion > target.reference.release) {
+            throw new Error(`rollback target "${key}@${targetRelease}" cannot read accepted profile release ${record.profileVersion}`);
+        }
+        const historical = registeredDefinition(key, record.profileVersion).collections.find((collection) => collection.key === record.collectionKey);
+        if (historical === undefined ||
+            historical.schemaVersion !== record.schemaVersion ||
+            normalizeDigest(historical.schemaDigest) !== normalizeDigest(record.schemaDigest)) {
+            throw new Error(`rollback target cannot read accepted schema for "${record.collectionKey}"`);
+        }
+    }
+}
+export function assertCompatibleManagedRelease(previous, next) {
+    const previousReference = previous.reference;
+    const nextReference = next.reference;
+    if (previousReference.kind !== 'managed' ||
+        nextReference.kind !== 'managed' ||
+        previousReference.definitionId !== nextReference.definitionId ||
+        nextReference.release !== previousReference.release + 1) {
+        throw new Error('managed releases must be consecutive revisions of one definition');
+    }
+    const previousTools = new Set((previous.variables ?? []).flatMap((entry) => entry.requiredFor));
+    const blueprint = managedSolutionBlueprint(previousReference.definitionId, previousReference.release);
+    if (blueprint)
+        previousTools.add(blueprint.tool);
+    for (const setting of previous.variables ?? []) {
+        const updated = next.variables?.find((entry) => entry.name === setting.name);
+        if (!updated ||
+            !compatibleProperty(setting.valueSchema, updated.valueSchema) ||
+            (setting.portal !== undefined && updated.portal === undefined))
+            throw new Error(`managed release changed setting compatibility for "${setting.name}"`);
+    }
+    for (const setting of next.variables ?? []) {
+        const old = previous.variables?.find((entry) => entry.name === setting.name);
+        if (!Object.hasOwn(setting, 'default') &&
+            setting.requiredFor.some((tool) => previousTools.has(tool) && !old?.requiredFor.includes(tool)))
+            throw new Error(`managed release added an unresolved requirement for "${setting.name}"`);
+    }
+    for (const oldCollection of previous.collections) {
+        const newCollection = next.collections.find((candidate) => candidate.key === oldCollection.key);
+        if (newCollection === undefined) {
+            throw new Error(`managed release removed collection "${oldCollection.key}"`);
+        }
+        if (stableJson(oldCollection.authority) !== stableJson(newCollection.authority)) {
+            throw new Error(`managed release changed authority for "${oldCollection.key}"`);
+        }
+        if (stableJson(oldCollection.behavior) !== stableJson(newCollection.behavior) &&
+            !isLegacyRequestUpgrade(oldCollection, newCollection)) {
+            throw new Error(`managed release changed behavior for "${oldCollection.key}"`);
+        }
+        if (!isLegacyRequestUpgrade(oldCollection, newCollection) &&
+            stableJson(oldCollection.management) !== stableJson(newCollection.management)) {
+            throw new Error(`managed release changed native controls for "${oldCollection.key}"`);
+        }
+        assertCompatibleSchema(oldCollection, newCollection);
+    }
+}
+function assertCompatibleSchema(previous, next) {
+    const oldSchema = objectSchema(previous.recordSchema, previous.key);
+    const newSchema = objectSchema(next.recordSchema, next.key);
+    if (oldSchema.type !== newSchema.type ||
+        oldSchema.additionalProperties !== newSchema.additionalProperties ||
+        stableJson(oldSchema.required) !== stableJson(newSchema.required)) {
+        throw new Error(`managed release changed required fields for "${previous.key}"`);
+    }
+    for (const [name, oldProperty] of Object.entries(oldSchema.properties)) {
+        const newProperty = newSchema.properties[name];
+        if (newProperty === undefined) {
+            throw new Error(`managed release removed field "${previous.key}.${name}"`);
+        }
+        if (!compatibleProperty(oldProperty, newProperty)) {
+            throw new Error(`managed release changed field semantics for "${previous.key}.${name}"`);
+        }
+    }
+    const changed = stableJson(previous.recordSchema) !== stableJson(next.recordSchema);
+    if (changed && next.schemaVersion <= previous.schemaVersion) {
+        throw new Error(`managed release changed schema without advancing "${previous.key}" version`);
+    }
+    if (!changed && next.schemaVersion !== previous.schemaVersion) {
+        throw new Error(`managed release advanced unchanged schema "${previous.key}"`);
+    }
+}
+function compatibleProperty(previous, next) {
+    if (!isObject(previous) || !isObject(next))
+        return stableJson(previous) === stableJson(next);
+    const oldEnum = stringArray(previous.enum);
+    const newEnum = stringArray(next.enum);
+    const withoutEnum = (value) => {
+        const { enum: ignored, ...rest } = value;
+        void ignored;
+        return rest;
+    };
+    if (stableJson(withoutEnum(previous)) !== stableJson(withoutEnum(next)))
+        return false;
+    if (oldEnum === undefined)
+        return newEnum === undefined;
+    return newEnum !== undefined && oldEnum.every((value) => newEnum.includes(value));
+}
+function objectSchema(schema, collection) {
+    if (!isObject(schema) || !isObject(schema.properties)) {
+        throw new Error(`managed collection "${collection}" does not use a supported object schema`);
+    }
+    return {
+        type: schema.type,
+        additionalProperties: schema.additionalProperties,
+        required: schema.required,
+        properties: schema.properties,
+    };
+}
+function registeredDefinition(key, release) {
+    const definition = builtInDefinitionAtRelease(key, release);
+    if (definition.reference.kind !== 'managed') {
+        throw new Error(`profile "${key}" is not a managed solution definition`);
+    }
+    return definition;
+}
+function assertSameDefinition(expected, actual, source) {
+    if (stableJson(expected) !== stableJson(actual)) {
+        throw new Error(`${source} does not match its immutable managed release`);
+    }
+}
+function cloneInstallation(installation) {
+    return {
+        ...installation,
+        scope: { ...installation.scope },
+        managedCollections: [...installation.managedCollections],
+        definition: structuredClone(installation.definition),
+    };
+}
+function normalizeDigest(value) {
+    return value.replace(/^sha256:/, '');
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string')
+        ? value
+        : undefined;
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value !== null && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+/** Immutable release rows used by schema backfill and release-gate inspection. */
+export function builtInManagedReleaseDefinitions() {
+    return Object.entries(BUILT_IN_SOLUTION_PROFILE_RELEASES).flatMap(([key, releases]) => releases
+        .filter(() => key !== 'b2b_saas')
+        .map((release) => builtInDefinitionAtRelease(key, release.version)));
+}
+function validateBuiltInManagedReleaseRegistry() {
+    for (const [key, releases] of Object.entries(BUILT_IN_SOLUTION_PROFILE_RELEASES)) {
+        if (key === 'b2b_saas')
+            continue;
+        for (let index = 0; index < releases.length; index += 1) {
+            if (releases[index]?.version !== index + 1) {
+                throw new Error(`managed definition "${key}" release history must be contiguous`);
+            }
+            if (index > 0) {
+                assertCompatibleManagedRelease(builtInDefinitionAtRelease(key, index), builtInDefinitionAtRelease(key, index + 1));
+            }
+        }
+    }
+}
+validateBuiltInManagedReleaseRegistry();
+//# sourceMappingURL=managed-releases.js.map

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-blueprints.js

@@ -0,0 +1,51 @@
+import { compileVariableDeclarations } from '@noodle-borg/compiler';
+/** Curated first-party executable intent; collection declarations never synthesize tools. */
+const BLUEPRINTS = {
+    travel: {
+        release: 3,
+        collection: 'travel_requests',
+        tool: 'submit_travel_request',
+        title: 'Submit a travel request',
+        description: 'Send a travel service request to the business for staff review. This records a request; it does not change a reservation or issue a refund.',
+    },
+    ecommerce: {
+        release: 2,
+        collection: 'return_requests',
+        tool: 'submit_commerce_request',
+        title: 'Submit a return request',
+        description: 'Send an order or return request to the business for staff review. This records a request; it does not issue a refund or change an order.',
+    },
+    restaurant: {
+        release: 2,
+        collection: 'guest_requests',
+        tool: 'submit_restaurant_request',
+        title: 'Submit a guest request',
+        description: 'Send a guest request to the restaurant for staff review. This records a request; it does not confirm a reservation or place an order.',
+    },
+};
+export function managedSolutionBlueprint(key, release) {
+    if (key === 'b2b_saas')
+        return undefined;
+    const blueprint = BLUEPRINTS[key];
+    return blueprint.release === release ? blueprint : undefined;
+}
+export function managedSolutionVariables() {
+    const errors = [];
+    const variables = compileVariableDeclarations([
+        {
+            name: 'WEBSITE_ORIGIN',
+            schemaVersion: 1,
+            valueSchema: { type: 'string', minLength: 1, maxLength: 2048 },
+            portal: {
+                label: 'Website origin',
+                help: 'The exact HTTPS origin where your assistant will be embedded, for example https://www.example.com.',
+                group: 'Publishing',
+            },
+            requiredFor: [],
+        },
+    ], [], errors);
+    if (errors.length > 0)
+        throw new Error('Invalid first-party solution settings declaration');
+    return variables;
+}
+//# sourceMappingURL=managed-solution-blueprints.js.map

package/node_modules/@noodle-borg/service/dist/business-information/managed-solution-executable.js

@@ -0,0 +1,76 @@
+import { projectManagedCollectionControls, RECORD_OPERATION_SIGNATURES, } from '@noodle-borg/compiler';
+import { collectionToPublicWire } from '../routes/business-information-wire.js';
+import { managedSolutionBlueprint } from './managed-solution-blueprints.js';
+/** System-owned manifest data for an explicitly curated solution, admitted by the ordinary compiler. */
+export function managedSolutionManifest(definition) {
+    const ref = definition.reference;
+    const blueprint = ref.kind === 'managed' ? managedSolutionBlueprint(ref.definitionId, ref.release) : undefined;
+    if (blueprint === undefined)
+        throw new Error('Managed solution executable is unavailable for this release');
+    const collection = definition.collections.find((entry) => entry.key === blueprint.collection);
+    if (collection === undefined)
+        throw new Error('Managed solution executable collection is missing');
+    return {
+        manifestVersion: '2',
+        server: {
+            name: ref.kind === 'managed' ? ref.definitionId : 'solution',
+            version: `${ref.kind === 'managed' ? ref.release : 1}.0.0`,
+            title: definition.title,
+            interactions: { confirmationFallback: 'host' },
+            instructions: `${definition.description} Request submission creates a record for staff review. Never claim that an external booking, payment, refund, order or reservation was completed.`,
+            variables: definition.variables?.map(({ schemaDigest: _, ...declaration }) => declaration),
+            collections: definition.collections.map((entry) => ({
+                name: entry.key,
+                title: entry.title,
+                description: entry.description,
+                schemaVersion: entry.schemaVersion,
+                recordSchema: entry.recordSchema,
+                ...projectManagedCollectionControls(entry),
+                summaryFields: entry.summaryFields,
+            })),
+            assistant: {
+                model: { kind: 'noodle-managed' },
+                allowedOrigins: ['${env.WEBSITE_ORIGIN}'],
+                surfaces: [
+                    {
+                        mode: 'public',
+                        origins: ['${env.WEBSITE_ORIGIN}'],
+                        capabilities: [{ kind: 'tool', name: blueprint.tool }],
+                    },
+                ],
+            },
+        },
+        connectors: { records: { id: 'noodle_records', version: '1.0.0' } },
+        tools: [
+            {
+                name: blueprint.tool,
+                title: blueprint.title,
+                description: blueprint.description,
+                inputSchema: collectionToPublicWire(collection).recordSchema,
+                outputSchema: RECORD_OPERATION_SIGNATURES.submit_record?.output,
+                annotations: {
+                    confirm: true,
+                    readOnlyHint: false,
+                    destructiveHint: false,
+                    idempotentHint: false,
+                    openWorldHint: false,
+                },
+                fulfilment: {
+                    steps: [
+                        {
+                            id: 'submit',
+                            use: 'records.submit_record',
+                            args: { collection: collection.key, payload: '${input}' },
+                        },
+                    ],
+                    output: {
+                        ok: '${steps.submit.ok}',
+                        recordId: '${steps.submit.recordId}',
+                        revision: '${steps.submit.revision}',
+                    },
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=managed-solution-executable.js.map