@marifold/core 0.64.1 → 0.66.0

package/dist/app/SkillAppCompiler.js

@@ -42,9 +42,12 @@ const SAFE_APP_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const SAFE_LOCAL_NAME = /^[a-zA-Z][a-zA-Z0-9_]*$/;
 const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9_-]*$/;
 const SAFE_PROVIDER_NAME = /^[a-z0-9][a-z0-9_-]*$/;
+const SAFE_PROFILE_NAME = /^[A-Za-z0-9_-]+$/;
 const ALLOWED_BUILDERS = new Set([
-    'App', 'Button', 'Column', 'Row', 'Select', 'Spacer', 'State', 'Textarea',
-    'TextResult', 'defineSkillApp', 'registerModel', 'registerSkill', 'trigger', 'useSkill',
+    'App', 'AttachmentState', 'Attachments', 'Button', 'Column', 'FileAccess',
+    'FolderAccess', 'Row', 'Select', 'Spacer', 'State', 'Textarea',
+    'TextResult', 'defineSkillApp', 'registerModel', 'registerProfile', 'registerSkill',
+    'trigger', 'useProfileSkill', 'useSkill',
 ]);
 /** Compile the restricted TypeScript authoring syntax into renderer-neutral data.
  * The source is inspected as an AST and is never evaluated or imported. */
@@ -63,7 +66,9 @@ function compileSkillApp(source, sourcePath = 'skillapp.ts') {
         imports: new Map(),
         values: new Map(),
         states: [],
+        attachmentStates: [],
         models: [],
+        profiles: [],
         skills: [],
         operations: [],
         triggers: [],
@@ -89,6 +94,8 @@ function compileSkillApp(source, sourcePath = 'skillapp.ts') {
             const tagged = requireTagged(value, 'skillapp', statement.expression, state, sourcePath);
             state.template = {
                 app: requireObject(tagged.app, 'defineSkillApp app', statement.expression, state, sourcePath),
+                permissions: requireArray(tagged.permissions ?? [], 'defineSkillApp permissions', statement.expression, state, sourcePath)
+                    .map(permission => requireTagged(permission, 'permission', statement.expression, state, sourcePath)),
                 ui: requireTagged(tagged.ui, 'component', statement.expression, state, sourcePath),
             };
         }
@@ -99,16 +106,20 @@ function compileSkillApp(source, sourcePath = 'skillapp.ts') {
     if (!state.template)
         throw MarifoldError_1.MarifoldError.appInvalid('SkillApp must export default defineSkillApp({...}).', sourcePath);
     const app = normalizeAppInfo(state.template.app, state, sourcePath);
+    const permissions = normalizePermissions(state.template.permissions, state, sourcePath);
     const layoutRoot = normalizeComponent(state.template.ui, state, sourcePath);
     if (layoutRoot.component !== 'app') {
         throw MarifoldError_1.MarifoldError.appInvalid('defineSkillApp.ui must be App([...]).', sourcePath);
     }
     validateReferences(state, layoutRoot.children ?? [], sourcePath);
     return {
-        schema: SkillAppSchema_1.SKILL_APP_SCHEMA,
+        schema: state.profiles.length > 0 ? SkillAppSchema_1.SKILL_APP_PROFILE_SCHEMA : SkillAppSchema_1.SKILL_APP_SCHEMA,
         app,
         states: state.states,
+        attachmentStates: state.attachmentStates,
+        permissions,
         models: state.models,
+        profiles: state.profiles,
         skills: state.skills,
         operations: state.operations,
         triggers: state.triggers,
@@ -156,20 +167,12 @@ function registerDeclaration(name, value, node, state, sourcePath) {
     if (value.__kind === 'state') {
         state.states.push({ name, initial: requireString(value.initial, 'State initial value', node, state, sourcePath) });
     }
+    else if (value.__kind === 'attachment_state') {
+        state.attachmentStates.push({ name });
+    }
     else if (value.__kind === 'model') {
         const id = requireString(value.id, 'model id', node, state, sourcePath);
-        const separator = id.indexOf('/');
-        if (separator <= 0 || separator === id.length - 1) {
-            throw invalidAt(state.sourceFile, node.pos, `Model '${id}' must use provider/model format.`, sourcePath);
-        }
-        const provider = id.slice(0, separator);
-        if (!SAFE_PROVIDER_NAME.test(provider)) {
-            throw invalidAt(state.sourceFile, node.pos, `Invalid model provider '${provider}'.`, sourcePath);
-        }
-        const model = id.slice(separator + 1);
-        if (model.trim() !== model || model.length === 0) {
-            throw invalidAt(state.sourceFile, node.pos, `Invalid model id '${model}'.`, sourcePath);
-        }
+        const { provider, model } = parseModelId(id, node, state, sourcePath);
         state.models.push({
             name,
             provider,
@@ -177,6 +180,28 @@ function registerDeclaration(name, value, node, state, sourcePath) {
             think: requireBoolean(value.think, 'model think', node, state, sourcePath),
         });
     }
+    else if (value.__kind === 'profile') {
+        const profile = requireString(value.profileName, 'profile name', node, state, sourcePath);
+        if (!SAFE_PROFILE_NAME.test(profile)) {
+            throw invalidAt(state.sourceFile, node.pos, `Invalid profile name '${profile}'.`, sourcePath);
+        }
+        const modelId = value.modelId === undefined
+            ? undefined
+            : requireString(value.modelId, 'profile model override', node, state, sourcePath);
+        const modelOverride = modelId === undefined
+            ? undefined
+            : parseModelId(modelId, node, state, sourcePath);
+        state.profiles.push({
+            name,
+            profile,
+            ...(modelOverride ?? {}),
+            ...(value.think !== undefined
+                ? { think: requireBoolean(value.think, 'profile think', node, state, sourcePath) }
+                : {}),
+            memory: requireBoolean(value.memory, 'profile memory', node, state, sourcePath),
+            history: requireBoolean(value.history, 'profile history', node, state, sourcePath),
+        });
+    }
     else if (value.__kind === 'skill') {
         const skillName = requireString(value.skillName, 'skill name', node, state, sourcePath);
         if (!SAFE_SKILL_NAME.test(skillName)) {
@@ -189,18 +214,62 @@ function registerDeclaration(name, value, node, state, sourcePath) {
         });
     }
     else if (value.__kind === 'operation') {
-        state.operations.push({
-            name,
-            model: requireNamedReference(value.model, 'model', node, state, sourcePath),
-            skill: requireNamedReference(value.skill, 'skill', node, state, sourcePath, true),
-            parameters: Object.fromEntries(Object.entries(requireObject(value.parameters, 'operation parameters', node, state, sourcePath)).map(([parameter, reference]) => [
-                parameter,
-                requireNamedReference(reference, 'state', node, state, sourcePath),
-            ])),
-            requiredInputs: [],
-            output: requireNamedReference(value.output, 'state', node, state, sourcePath),
-            execution: { memory: false, history: false, profileContext: false },
-        });
+        const parameters = Object.fromEntries(Object.entries(requireObject(value.parameters, 'operation parameters', node, state, sourcePath)).map(([parameter, reference]) => [
+            parameter,
+            requireNamedReference(reference, 'state', node, state, sourcePath),
+        ]));
+        if (value.profile !== undefined) {
+            const profile = requireTagged(value.profile, 'profile', node, state, sourcePath);
+            const result = requireTagged(value.result, 'text_result', node, state, sourcePath);
+            const skillName = value.skillName === undefined
+                ? undefined
+                : requireString(value.skillName, 'profile skill name', node, state, sourcePath);
+            const skillState = value.skillState === undefined
+                ? undefined
+                : requireNamedReference(value.skillState, 'state', node, state, sourcePath);
+            const skillOptions = value.skillOptions === undefined
+                ? undefined
+                : requireSkillOptionValues(value.skillOptions, node, state, sourcePath);
+            state.operations.push({
+                name,
+                profile: requireName(profile, 'profile', node, state, sourcePath),
+                ...(skillName ? { skill: skillName } : {}),
+                ...(skillState ? { skillState } : {}),
+                ...(skillOptions ? { skillOptions } : {}),
+                ...(value.stripSkillName !== undefined
+                    ? { stripSkillName: requireBoolean(value.stripSkillName, 'stripSkillName', node, state, sourcePath) }
+                    : {}),
+                ...(value.input !== undefined
+                    ? { input: requireNamedReference(value.input, 'state', node, state, sourcePath) }
+                    : {}),
+                ...(value.attachments !== undefined
+                    ? { attachments: requireNamedReference(value.attachments, 'attachment_state', node, state, sourcePath) }
+                    : {}),
+                parameters,
+                requiredInputs: [],
+                output: requireNamedReference(value.output, 'state', node, state, sourcePath),
+                result: {
+                    kind: 'text',
+                    trim: requireBoolean(result.trim, 'result trim', node, state, sourcePath),
+                },
+                execution: {
+                    memory: requireBoolean(profile.memory, 'profile memory', node, state, sourcePath),
+                    history: requireBoolean(profile.history, 'profile history', node, state, sourcePath),
+                    profileContext: true,
+                },
+            });
+        }
+        else {
+            state.operations.push({
+                name,
+                model: requireNamedReference(value.model, 'model', node, state, sourcePath),
+                skill: requireNamedReference(value.skill, 'skill', node, state, sourcePath, true),
+                parameters,
+                requiredInputs: [],
+                output: requireNamedReference(value.output, 'state', node, state, sourcePath),
+                execution: { memory: false, history: false, profileContext: false },
+            });
+        }
     }
 }
 function evaluateExpression(rawNode, state, sourcePath, declarationName) {
@@ -269,6 +338,25 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
         case 'State':
             exactArgs(name, args, 1, node, state, sourcePath);
             return { __kind: 'state', initial: requireString(args[0], 'State initial value', node, state, sourcePath) };
+        case 'AttachmentState':
+            exactArgs(name, args, 0, node, state, sourcePath);
+            return { __kind: 'attachment_state' };
+        case 'FileAccess':
+        case 'FolderAccess': {
+            exactArgs(name, args, 2, node, state, sourcePath);
+            const options = requireObject(args[1], `${name} options`, node, state, sourcePath);
+            rejectUnknown(options, ['access'], name, node, state, sourcePath);
+            const access = requireString(options.access, `${name} access`, node, state, sourcePath);
+            if (access !== 'read') {
+                throw invalidAt(state.sourceFile, node.pos, `${name} access must be "read".`, sourcePath);
+            }
+            return {
+                __kind: 'permission',
+                resource: name === 'FileAccess' ? 'file' : 'folder',
+                path: requireNonEmptyString(args[0], `${name} path`, node, state, sourcePath),
+                access,
+            };
+        }
         case 'registerModel': {
             argsRange(name, args, 1, 2, node, state, sourcePath);
             const options = args[1] === undefined ? {} : requireObject(args[1], 'registerModel options', node, state, sourcePath);
@@ -279,6 +367,23 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
                 think: options.think === undefined ? false : requireBoolean(options.think, 'think', node, state, sourcePath),
             };
         }
+        case 'registerProfile': {
+            argsRange(name, args, 1, 2, node, state, sourcePath);
+            const options = args[1] === undefined ? {} : requireObject(args[1], 'registerProfile options', node, state, sourcePath);
+            rejectUnknown(options, ['model', 'think', 'memory', 'history'], name, node, state, sourcePath);
+            return {
+                __kind: 'profile',
+                profileName: requireString(args[0], 'profile name', node, state, sourcePath),
+                ...(options.model !== undefined
+                    ? { modelId: requireString(options.model, 'model', node, state, sourcePath) }
+                    : {}),
+                ...(options.think !== undefined
+                    ? { think: requireBoolean(options.think, 'think', node, state, sourcePath) }
+                    : {}),
+                memory: options.memory === undefined ? false : requireBoolean(options.memory, 'memory', node, state, sourcePath),
+                history: options.history === undefined ? false : requireBoolean(options.history, 'history', node, state, sourcePath),
+            };
+        }
         case 'TextResult': {
             argsRange(name, args, 0, 1, node, state, sourcePath);
             const options = args[0] === undefined ? {} : requireObject(args[0], 'TextResult options', node, state, sourcePath);
@@ -314,6 +419,45 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
                 output: requireTagged(options.output, 'state', node, state, sourcePath),
             };
         }
+        case 'useProfileSkill': {
+            exactArgs(name, args, 3, node, state, sourcePath);
+            const profile = requireTagged(args[0], 'profile', node, state, sourcePath);
+            const skillName = typeof args[1] === 'string' ? args[1] : undefined;
+            const skillState = skillName === undefined
+                ? requireTagged(args[1], 'state', node, state, sourcePath)
+                : undefined;
+            if (skillName !== undefined && !SAFE_SKILL_NAME.test(skillName)) {
+                throw invalidAt(state.sourceFile, node.pos, `Invalid profile skill name '${skillName}'.`, sourcePath);
+            }
+            const options = requireObject(args[2], 'useProfileSkill options', node, state, sourcePath);
+            rejectUnknown(options, ['skills', 'input', 'attachments', 'stripSkillName', 'parameters', 'output', 'result'], name, node, state, sourcePath);
+            if (skillName !== undefined && options.skills !== undefined) {
+                throw invalidAt(state.sourceFile, node.pos, 'useProfileSkill.skills is only valid when the Skill is selected by State.', sourcePath);
+            }
+            if (skillState !== undefined && options.skills === undefined) {
+                throw invalidAt(state.sourceFile, node.pos, 'A state-selected profile Skill requires a non-empty useProfileSkill.skills allowlist.', sourcePath);
+            }
+            return {
+                __kind: 'operation',
+                profile,
+                ...(skillName !== undefined ? { skillName } : { skillState }),
+                ...(options.skills !== undefined ? { skillOptions: options.skills } : {}),
+                ...(options.input !== undefined
+                    ? { input: requireTagged(options.input, 'state', node, state, sourcePath) }
+                    : {}),
+                ...(options.attachments !== undefined
+                    ? { attachments: requireTagged(options.attachments, 'attachment_state', node, state, sourcePath) }
+                    : {}),
+                ...(options.stripSkillName !== undefined
+                    ? { stripSkillName: requireBoolean(options.stripSkillName, 'stripSkillName', node, state, sourcePath) }
+                    : {}),
+                parameters: options.parameters === undefined
+                    ? {}
+                    : requireObject(options.parameters, 'useProfileSkill parameters', node, state, sourcePath),
+                output: requireTagged(options.output, 'state', node, state, sourcePath),
+                result: requireTagged(options.result, 'text_result', node, state, sourcePath),
+            };
+        }
         case 'trigger': {
             exactArgs(name, args, 2, node, state, sourcePath);
             const operation = requireTagged(args[0], 'operation', node, state, sourcePath);
@@ -342,10 +486,13 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
         case 'defineSkillApp': {
             exactArgs(name, args, 1, node, state, sourcePath);
             const template = requireObject(args[0], 'defineSkillApp template', node, state, sourcePath);
-            rejectUnknown(template, ['app', 'ui'], name, node, state, sourcePath);
+            rejectUnknown(template, ['app', 'permissions', 'ui'], name, node, state, sourcePath);
             return {
                 __kind: 'skillapp',
                 app: requireObject(template.app, 'app metadata', node, state, sourcePath),
+                permissions: template.permissions === undefined
+                    ? []
+                    : requireArray(template.permissions, 'defineSkillApp permissions', node, state, sourcePath),
                 ui: requireTagged(template.ui, 'component', node, state, sourcePath),
             };
         }
@@ -366,7 +513,7 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
         case 'Textarea': {
             argsRange(name, args, 2, 3, node, state, sourcePath);
             const options = args[2] === undefined ? {} : requireObject(args[2], 'Textarea options', node, state, sourcePath);
-            rejectUnknown(options, ['showLabel', 'grow', 'editable', 'copyable', 'placeholder'], name, node, state, sourcePath);
+            rejectUnknown(options, ['showLabel', 'grow', 'editable', 'copyable', 'rows', 'autoGrow', 'placeholder'], name, node, state, sourcePath);
             return {
                 __kind: 'component', component: 'textarea', label: requireNonEmptyString(args[0], 'Textarea label', node, state, sourcePath),
                 bind: requireTagged(args[1], 'state', node, state, sourcePath), options,
@@ -377,18 +524,28 @@ function evaluateCall(node, state, sourcePath, _declarationName) {
             const options = requireObject(args[2], 'Select options', node, state, sourcePath);
             rejectUnknown(options, ['options', 'showLabel', 'grow'], name, node, state, sourcePath);
             const choices = requireArray(options.options, 'Select options.options', node, state, sourcePath)
-                .map(value => requireNonEmptyString(value, 'Select option', node, state, sourcePath));
+                .map(value => requireSelectOption(value, node, state, sourcePath));
             if (choices.length === 0)
                 throw invalidAt(state.sourceFile, node.pos, 'Select options cannot be empty.', sourcePath);
             return {
                 __kind: 'component', component: 'select', label: requireNonEmptyString(args[0], 'Select label', node, state, sourcePath),
-                bind: requireTagged(args[1], 'state', node, state, sourcePath), options: { ...options, options: choices },
+                bind: requireTagged(args[1], 'state', node, state, sourcePath),
+                options: { ...options, options: choices },
+            };
+        }
+        case 'Attachments': {
+            argsRange(name, args, 2, 3, node, state, sourcePath);
+            const options = args[2] === undefined ? {} : requireObject(args[2], 'Attachments options', node, state, sourcePath);
+            rejectUnknown(options, ['showLabel', 'grow'], name, node, state, sourcePath);
+            return {
+                __kind: 'component', component: 'attachments', label: requireNonEmptyString(args[0], 'Attachments label', node, state, sourcePath),
+                bind: requireTagged(args[1], 'attachment_state', node, state, sourcePath), options,
             };
         }
         case 'Button': {
             exactArgs(name, args, 2, node, state, sourcePath);
             const options = requireObject(args[1], 'Button options', node, state, sourcePath);
-            rejectUnknown(options, ['trigger', 'emphasis'], name, node, state, sourcePath);
+            rejectUnknown(options, ['trigger', 'emphasis', 'alignToField'], name, node, state, sourcePath);
             return {
                 __kind: 'component', component: 'button', label: requireNonEmptyString(args[0], 'Button label', node, state, sourcePath),
                 operation: requireTagged(options.trigger, 'operation', node, state, sourcePath), options,
@@ -410,20 +567,28 @@ function normalizeComponent(value, state, sourcePath, depth = 0) {
     if (value.label !== undefined)
         item.label = requireString(value.label, `${component} label`, state.sourceFile, state, sourcePath);
     if (value.bind !== undefined)
-        item.bind = requireNamedReference(value.bind, 'state', state.sourceFile, state, sourcePath);
+        item.bind = requireNamedReference(value.bind, component === 'attachments' ? 'attachment_state' : 'state', state.sourceFile, state, sourcePath);
     if (value.operation !== undefined)
         item.trigger = requireName(requireTagged(value.operation, 'operation', state.sourceFile, state, sourcePath), 'operation', state.sourceFile, state, sourcePath);
     copyBoolean(options, 'showLabel', item, state, sourcePath);
     copyBoolean(options, 'grow', item, state, sourcePath);
     copyBoolean(options, 'editable', item, state, sourcePath);
     copyBoolean(options, 'copyable', item, state, sourcePath);
+    copyBoolean(options, 'autoGrow', item, state, sourcePath);
+    copyBoolean(options, 'alignToField', item, state, sourcePath);
+    if (options.rows !== undefined) {
+        item.rows = requireNonNegativeInteger(options.rows, 'rows', state.sourceFile, state, sourcePath);
+        if (item.rows < 1 || item.rows > 40) {
+            throw MarifoldError_1.MarifoldError.appInvalid('Textarea rows must be between 1 and 40.', sourcePath);
+        }
+    }
     copyString(options, 'placeholder', item, state, sourcePath);
     copyString(options, 'gap', item, state, sourcePath);
     copyString(options, 'responsive', item, state, sourcePath);
     copyString(options, 'emphasis', item, state, sourcePath);
     if (options.options !== undefined) {
         item.options = requireArray(options.options, 'Select options', state.sourceFile, state, sourcePath)
-            .map(choice => requireString(choice, 'Select option', state.sourceFile, state, sourcePath));
+            .map(choice => requireSelectOption(choice, state.sourceFile, state, sourcePath));
     }
     if (item.component === 'textarea' && item.editable === undefined)
         item.editable = true;
@@ -438,30 +603,62 @@ function normalizeComponent(value, state, sourcePath, depth = 0) {
     if (item.emphasis !== undefined && !['primary', 'secondary'].includes(item.emphasis)) {
         throw MarifoldError_1.MarifoldError.appInvalid(`Invalid button emphasis '${item.emphasis}'.`, sourcePath);
     }
-    if (item.options && new Set(item.options).size !== item.options.length) {
+    if (item.options && new Set(item.options.map(selectOptionValue)).size !== item.options.length) {
         throw MarifoldError_1.MarifoldError.appInvalid('Select options must be unique.', sourcePath);
     }
     return item;
 }
 function validateReferences(state, layout, sourcePath) {
     const stateNames = new Set(state.states.map(item => item.name));
+    const attachmentStateNames = new Set(state.attachmentStates.map(item => item.name));
     const modelNames = new Set(state.models.map(item => item.name));
+    const profileNames = new Set(state.profiles.map(item => item.name));
     const skillNames = new Set(state.skills.map(item => item.name));
     const operationNames = new Set(state.operations.map(item => item.name));
     assertUnique(state.models.map(item => item.name), 'model declarations', sourcePath);
+    assertUnique(state.profiles.map(item => item.name), 'profile declarations', sourcePath);
     assertUnique(state.skills.map(item => item.name), 'registered Skills', sourcePath);
     assertUnique(state.operations.map(item => item.name), 'operations', sourcePath);
+    assertUnique(state.attachmentStates.map(item => item.name), 'attachment state declarations', sourcePath);
     if (state.states.length === 0)
         throw MarifoldError_1.MarifoldError.appInvalid('SkillApp must declare at least one State.', sourcePath);
     if (state.operations.length === 0)
-        throw MarifoldError_1.MarifoldError.appInvalid('SkillApp must declare at least one useSkill operation.', sourcePath);
+        throw MarifoldError_1.MarifoldError.appInvalid('SkillApp must declare at least one useSkill or useProfileSkill operation.', sourcePath);
     for (const operation of state.operations) {
-        if (!modelNames.has(operation.model))
-            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing model '${operation.model}'.`, sourcePath);
-        if (!skillNames.has(operation.skill))
-            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing skill '${operation.skill}'.`, sourcePath);
+        if (operation.profile) {
+            if (!profileNames.has(operation.profile))
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing profile '${operation.profile}'.`, sourcePath);
+            if (operation.model)
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' cannot reference both a profile and model.`, sourcePath);
+            const fixedSkill = operation.skill !== undefined;
+            const selectedSkill = operation.skillState !== undefined;
+            if (fixedSkill === selectedSkill) {
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' must reference exactly one fixed or state-selected profile Skill.`, sourcePath);
+            }
+            if (selectedSkill) {
+                if (!stateNames.has(operation.skillState))
+                    throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing Skill state '${operation.skillState}'.`, sourcePath);
+                if (!operation.skillOptions?.length)
+                    throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' requires a non-empty Skill allowlist.`, sourcePath);
+                const initial = state.states.find(candidate => candidate.name === operation.skillState)?.initial;
+                if (initial !== undefined && !operation.skillOptions.includes(initial)) {
+                    throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' initial Skill '${initial}' is not allowlisted.`, sourcePath);
+                }
+            }
+        }
+        else {
+            if (!operation.model || !modelNames.has(operation.model))
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing model '${operation.model ?? ''}'.`, sourcePath);
+            if (!operation.skill || !skillNames.has(operation.skill))
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing skill '${operation.skill ?? ''}'.`, sourcePath);
+        }
         if (!stateNames.has(operation.output))
             throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing output state '${operation.output}'.`, sourcePath);
+        if (operation.input && !stateNames.has(operation.input))
+            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing input state '${operation.input}'.`, sourcePath);
+        if (operation.attachments && !attachmentStateNames.has(operation.attachments)) {
+            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing attachment state '${operation.attachments}'.`, sourcePath);
+        }
         for (const name of Object.values(operation.parameters)) {
             if (!stateNames.has(name))
                 throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' references missing state '${name}'.`, sourcePath);
@@ -470,16 +667,31 @@ function validateReferences(state, layout, sourcePath) {
     const layoutItems = flatten(layout);
     if (layoutItems.length > 100)
         throw MarifoldError_1.MarifoldError.appInvalid('SkillApp layout cannot exceed 100 components.', sourcePath);
+    for (const operation of state.operations.filter(candidate => candidate.skillState)) {
+        const selectors = layoutItems.filter(item => item.component === 'select' && item.bind === operation.skillState);
+        if (selectors.length === 0) {
+            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' Skill state '${operation.skillState}' must bind to Select.`, sourcePath);
+        }
+        const selectable = new Set(selectors.flatMap(item => (item.options ?? []).map(selectOptionValue)));
+        const allowlisted = new Set(operation.skillOptions ?? []);
+        if (selectable.size !== allowlisted.size || [...selectable].some(skill => !allowlisted.has(skill))) {
+            throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' Select options must exactly match its Skill allowlist.`, sourcePath);
+        }
+    }
     for (const item of layoutItems) {
         if (item.component === 'app')
             throw MarifoldError_1.MarifoldError.appInvalid('App(...) can only be the root UI component.', sourcePath);
-        if (item.bind && !stateNames.has(item.bind))
+        if (item.bind && item.component === 'attachments' && !attachmentStateNames.has(item.bind)) {
+            throw MarifoldError_1.MarifoldError.appInvalid(`Layout references missing attachment state '${item.bind}'.`, sourcePath);
+        }
+        if (item.bind && item.component !== 'attachments' && !stateNames.has(item.bind)) {
             throw MarifoldError_1.MarifoldError.appInvalid(`Layout references missing state '${item.bind}'.`, sourcePath);
+        }
         if (item.trigger && !operationNames.has(item.trigger))
             throw MarifoldError_1.MarifoldError.appInvalid(`Button references missing operation '${item.trigger}'.`, sourcePath);
         if (item.component === 'select' && item.bind) {
             const initial = state.states.find(candidate => candidate.name === item.bind)?.initial;
-            if (initial !== undefined && !(item.options ?? []).includes(initial)) {
+            if (initial !== undefined && !(item.options ?? []).map(selectOptionValue).includes(initial)) {
                 throw MarifoldError_1.MarifoldError.appInvalid(`Select state '${item.bind}' initial value must be one of its options.`, sourcePath);
             }
         }
@@ -494,9 +706,11 @@ function validateReferences(state, layout, sourcePath) {
     }
     const outputStates = new Set(state.operations.map(operation => operation.output));
     for (const operation of state.operations) {
-        for (const input of Object.values(operation.parameters)) {
+        for (const input of [operation.input, operation.skillState, ...Object.values(operation.parameters)]) {
+            if (!input)
+                continue;
             if (outputStates.has(input))
-                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' cannot use output state '${input}' as a parameter in v1.`, sourcePath);
+                throw MarifoldError_1.MarifoldError.appInvalid(`Operation '${operation.name}' cannot use output state '${input}' as an input.`, sourcePath);
         }
     }
     for (const item of layoutItems) {
@@ -516,6 +730,32 @@ function validateReferences(state, layout, sourcePath) {
         }
     }
 }
+function normalizePermissions(values, state, sourcePath) {
+    const permissions = values.map(value => ({
+        kind: requireString(value.resource, 'permission resource', state.sourceFile, state, sourcePath),
+        path: requireNonEmptyString(value.path, 'permission path', state.sourceFile, state, sourcePath),
+        access: requireString(value.access, 'permission access', state.sourceFile, state, sourcePath),
+    }));
+    const duplicate = permissions.find((permission, index) => permissions.findIndex(candidate => (candidate.kind === permission.kind && candidate.path === permission.path)) !== index);
+    if (duplicate)
+        throw MarifoldError_1.MarifoldError.appInvalid(`Duplicate ${duplicate.kind} permission '${duplicate.path}'.`, sourcePath);
+    return permissions;
+}
+function parseModelId(id, node, state, sourcePath) {
+    const separator = id.indexOf('/');
+    if (separator <= 0 || separator === id.length - 1) {
+        throw invalidAt(state.sourceFile, node.pos, `Model '${id}' must use provider/model format.`, sourcePath);
+    }
+    const provider = id.slice(0, separator);
+    if (!SAFE_PROVIDER_NAME.test(provider)) {
+        throw invalidAt(state.sourceFile, node.pos, `Invalid model provider '${provider}'.`, sourcePath);
+    }
+    const model = id.slice(separator + 1);
+    if (model.trim() !== model || model.length === 0) {
+        throw invalidAt(state.sourceFile, node.pos, `Invalid model id '${model}'.`, sourcePath);
+    }
+    return { provider, model };
+}
 function assertUnique(values, label, sourcePath) {
     const seen = new Set();
     for (const value of values) {
@@ -572,6 +812,36 @@ function requireArray(value, label, node, state, sourcePath) {
         return value;
     throw invalidAt(state.sourceFile, node.pos, `Expected ${label} to be an array.`, sourcePath);
 }
+function requireSelectOption(value, node, state, sourcePath) {
+    if (typeof value === 'string') {
+        return requireNonEmptyString(value, 'Select option', node, state, sourcePath);
+    }
+    const option = requireObject(value, 'Select option', node, state, sourcePath);
+    rejectUnknown(option, ['label', 'value'], 'Select option', node, state, sourcePath);
+    return {
+        label: requireNonEmptyString(option.label, 'Select option label', node, state, sourcePath),
+        value: requireNonEmptyString(option.value, 'Select option value', node, state, sourcePath),
+    };
+}
+function requireSkillOptionValues(value, node, state, sourcePath) {
+    const skills = requireArray(value, 'useProfileSkill skills', node, state, sourcePath)
+        .map(option => selectOptionValue(requireSelectOption(option, node, state, sourcePath)));
+    if (skills.length === 0) {
+        throw invalidAt(state.sourceFile, node.pos, 'useProfileSkill.skills cannot be empty.', sourcePath);
+    }
+    for (const skill of skills) {
+        if (!SAFE_SKILL_NAME.test(skill)) {
+            throw invalidAt(state.sourceFile, node.pos, `Invalid profile skill name '${skill}'.`, sourcePath);
+        }
+    }
+    if (new Set(skills).size !== skills.length) {
+        throw invalidAt(state.sourceFile, node.pos, 'useProfileSkill.skills must be unique.', sourcePath);
+    }
+    return skills;
+}
+function selectOptionValue(option) {
+    return typeof option === 'string' ? option : option.value;
+}
 function requireString(value, label, node, state, sourcePath) {
     if (typeof value === 'string')
         return value;