@happyvertical/smrt-planner 0.0.1 → 0.1.0

package/dist/index.js

@@ -1,5 +1,6 @@
 /**
- * smrt planner as a package: mount the `Planner` component in a host layout,
+ * smrt planner as a package: mount `Planner` for the full app shell, or
+ * `PlannerControls` inside a host-owned shell,
  * drive it with the typed command set (`./commands` has no UI in it), and read
  * its plan as a compact snapshot.
  *
@@ -12,5 +13,9 @@ export { parseKitchenConfig, sendToKitchen, } from "./kitchen/client.js";
 export { KITCHEN_FRAGMENT_KEY, readKitchenFragment, } from "./kitchen/fragment.js";
 export { createPlannerAssistant, } from "./planner/assistant.js";
 export * from "./planner/commands/index.js";
+export { default as HostPlanner } from './planner/host/HostPlanner.svelte';
+export { createHostSession, } from "./planner/host/session.svelte.js";
 export { plannerController } from "./planner/instance.js";
 export { default as Planner } from './planner/Planner.svelte';
+export { default as PlannerControls } from './planner/PlannerControls.svelte';
+export { PLANNER_SHELL_EDGE_TOGGLES, PLANNER_SHELL_PANEL_DEFAULTS, plannerShellProps, } from "./planner/shell.js";

package/dist/inference/byo.svelte.d.ts

@@ -1,5 +1,5 @@
 import type { ChatModel } from '../assistant/transport.ts';
-import type { ByoPresetDefinition } from './config.ts';
+import type { ByoPresetDefinition, CredentialPersistence } from './config.ts';
 import { type ConnectionResult } from './openai.ts';
 /** Choices (not the key): which endpoint, its address and model, and whether it is in use. */
 export declare const BYO_PREFS_KEY = "smrt-planner:inference:v1";
@@ -24,6 +24,8 @@ export declare function loadByoKeys(storage: Storage | null): Record<string, Byo
 export type ByoTestStatus = 'idle' | 'testing' | 'ok' | 'failed';
 export interface ByoOptions {
     storage: Storage | null;
+    /** Credentials default to local storage for compatibility; hosted apps use memory. */
+    credentialPersistence?: CredentialPersistence;
     /** The config's `byo.presets`; default all built-ins. */
     presets?: readonly (string | ByoPresetDefinition)[];
     fetch?: typeof fetch;
@@ -33,8 +35,9 @@ export interface ByoOptions {
 /**
  * The visitor's own OpenAI-compatible endpoint: the preset they picked, its
  * address, model and key, a connection test, and whether the assistant uses
- * it. The key lives only in this browser's localStorage and is only ever sent
- * as the Authorization header to the chosen address.
+ * it. The key lives in the configured credential store (tab memory for hosted
+ * policies, localStorage for the compatible standalone default) and is only
+ * ever sent as the Authorization header to the chosen address.
  */
 export declare class ByoModel {
     readonly presets: ByoPresetDefinition[];
@@ -45,6 +48,7 @@ export declare class ByoModel {
     testStatus: ByoTestStatus;
     testMessage: string;
     private readonly options;
+    private readonly credentialStorage;
     constructor(options: ByoOptions);
     get preset(): ByoPresetDefinition | undefined;
     get baseUrl(): string;
@@ -82,5 +86,5 @@ export declare class ByoModel {
  * (a mounted `Planner` in byo mode has no AI page of its own). Null when none
  * is connected or what was saved is incomplete.
  */
-export declare function savedByoChat(storage: Storage | null, presets?: readonly (string | ByoPresetDefinition)[], fetcher?: typeof fetch): ChatModel | null;
+export declare function savedByoChat(storage: Storage | null, presets?: readonly (string | ByoPresetDefinition)[], fetcher?: typeof fetch, credentialPersistence?: CredentialPersistence): ChatModel | null;
 export {};

package/dist/inference/byo.svelte.js

@@ -17,15 +17,22 @@ export function loadByoPrefs(storage) {
         if (typeof value.preset === 'string')
             prefs.preset = value.preset;
         prefs.active = value.active === true;
+        let sanitized = false;
         if (isObject(value.entries)) {
             for (const [id, entry] of Object.entries(value.entries)) {
                 if (isObject(entry) &&
                     typeof entry.baseUrl === 'string' &&
                     typeof entry.model === 'string') {
-                    prefs.entries[id] = { baseUrl: entry.baseUrl, model: entry.model };
+                    const baseUrl = normalizeBaseUrl(entry.baseUrl) ?? '';
+                    sanitized ||= baseUrl !== entry.baseUrl;
+                    prefs.entries[id] = { baseUrl, model: entry.model };
                 }
             }
         }
+        if (sanitized) {
+            prefs.active = false;
+            storage?.setItem(BYO_PREFS_KEY, JSON.stringify(prefs));
+        }
     }
     catch {
         // Unreadable or unavailable: start empty.
@@ -59,8 +66,9 @@ export function loadByoKeys(storage) {
 /**
  * The visitor's own OpenAI-compatible endpoint: the preset they picked, its
  * address, model and key, a connection test, and whether the assistant uses
- * it. The key lives only in this browser's localStorage and is only ever sent
- * as the Authorization header to the chosen address.
+ * it. The key lives in the configured credential store (tab memory for hosted
+ * policies, localStorage for the compatible standalone default) and is only
+ * ever sent as the Authorization header to the chosen address.
  */
 export class ByoModel {
     presets;
@@ -71,11 +79,24 @@ export class ByoModel {
     testStatus = $state('idle');
     testMessage = $state('');
     options;
+    credentialStorage;
     constructor(options) {
         this.options = options;
+        this.credentialStorage =
+            options.credentialPersistence === 'memory' ? null : options.storage;
+        if (options.credentialPersistence === 'memory') {
+            // A hosted memory-only policy also removes a key an older local policy
+            // may have left on this origin. Endpoint/model preferences stay put.
+            try {
+                options.storage?.removeItem(BYO_KEYS_KEY);
+            }
+            catch {
+                // Storage can be unavailable; memory-only behavior still holds.
+            }
+        }
         this.presets = resolvePresets(options.presets);
         const prefs = loadByoPrefs(options.storage);
-        this.keys = loadByoKeys(options.storage);
+        this.keys = loadByoKeys(this.credentialStorage);
         this.entries = prefs.entries;
         this.presetId = this.presets.some((p) => p.id === prefs.preset)
             ? prefs.preset
@@ -226,13 +247,20 @@ export class ByoModel {
     }
     save() {
         try {
+            const entries = Object.fromEntries(Object.entries(this.entries).map(([id, entry]) => [
+                id,
+                {
+                    baseUrl: normalizeBaseUrl(entry.baseUrl) ?? '',
+                    model: entry.model,
+                },
+            ]));
             const prefs = {
                 preset: this.presetId,
                 active: this.active,
-                entries: { ...this.entries },
+                entries,
             };
             this.options.storage?.setItem(BYO_PREFS_KEY, JSON.stringify(prefs));
-            this.options.storage?.setItem(BYO_KEYS_KEY, JSON.stringify(this.keys));
+            this.credentialStorage?.setItem(BYO_KEYS_KEY, JSON.stringify(this.keys));
         }
         catch {
             // Not saved; the choice still holds for this visit.
@@ -244,7 +272,7 @@ export class ByoModel {
  * (a mounted `Planner` in byo mode has no AI page of its own). Null when none
  * is connected or what was saved is incomplete.
  */
-export function savedByoChat(storage, presets, fetcher) {
+export function savedByoChat(storage, presets, fetcher, credentialPersistence = 'local') {
     const prefs = loadByoPrefs(storage);
     if (!prefs.active)
         return null;
@@ -252,7 +280,7 @@ export function savedByoChat(storage, presets, fetcher) {
     const entry = prefs.entries[prefs.preset];
     const baseUrl = normalizeBaseUrl(entry?.baseUrl ?? preset?.baseUrl ?? '');
     const model = (entry?.model ?? preset?.model ?? '').trim();
-    const saved = loadByoKeys(storage)[prefs.preset];
+    const saved = loadByoKeys(credentialPersistence === 'memory' ? null : storage)[prefs.preset];
     const key = saved && saved.origin === originOf(baseUrl ?? '') ? saved.key : '';
     if (!preset || !baseUrl || !model)
         return null;

package/dist/inference/config.d.ts

@@ -9,7 +9,9 @@ import { type KitchenEndpoint } from '../kitchen/client.ts';
  * - `byo`: the visitor's own OpenAI-compatible endpoint (Ollama, OpenRouter,
  *   OpenAI, custom), configured on the AI page.
  */
-export type InferenceMode = 'browser' | 'host' | 'byo';
+export type InferenceMode = 'manual' | 'browser' | 'host' | 'byo';
+/** Where BYO provider credentials may live. Preferences are always separate. */
+export type CredentialPersistence = 'local' | 'memory';
 export declare const INFERENCE_MODES: readonly InferenceMode[];
 /** A bring-your-own endpoint the AI page offers. */
 export interface ByoPresetDefinition {
@@ -28,6 +30,10 @@ export interface ByoPresetDefinition {
 }
 export interface InferenceConfig {
     mode: InferenceMode;
+    /** Other modes the visitor may deliberately select, in display order. */
+    alternatives?: InferenceMode[];
+    /** Defaults to `local` for compatibility. Hosted apps should use `memory`. */
+    credentialPersistence?: CredentialPersistence;
     host?: {
         endpoint: string;
     };
@@ -41,21 +47,22 @@ export interface InferenceConfig {
     };
 }
 export declare const DEFAULT_INFERENCE: InferenceConfig;
+export declare const MANUAL_INFERENCE: InferenceConfig;
 /** The file name, served at `${base}/planner.config.json`. */
 export declare const CONFIG_FILE = "planner.config.json";
 export interface ConfigResult {
     config: InferenceConfig;
     /** The `kitchen` block (`smrt kitchen`), when the file has a usable one. */
     kitchen?: KitchenEndpoint;
-    /** Shown to the visitor when the config was unusable and `browser` is used instead. */
+    /** Shown when a present config was unusable and inference was disabled. */
     notice?: string;
 }
 /** http(s) only; a path-only endpoint (`/api/planner/chat`) is the host's own origin. */
 export declare function isUsableEndpoint(value: unknown): value is string;
 /**
- * Validate a parsed config. Anything wrong (unknown mode, `host` without a
- * usable endpoint, a malformed preset list) falls back to `browser` with a
- * notice, never to a half-working mode.
+ * Validate a parsed config. A missing config keeps the standalone browser
+ * default. A present but invalid config fails closed to manual planning with a
+ * visible notice; it never selects a provider or downloads a model.
  */
 export declare function validateInferenceConfig(value: unknown): ConfigResult;
 /** Parse the file's text. */

package/dist/inference/config.js

@@ -1,10 +1,12 @@
 import { parseKitchenConfig } from "../kitchen/client.js";
 export const INFERENCE_MODES = [
+    'manual',
     'browser',
     'host',
     'byo',
 ];
 export const DEFAULT_INFERENCE = { mode: 'browser' };
+export const MANUAL_INFERENCE = { mode: 'manual' };
 /** The file name, served at `${base}/planner.config.json`. */
 export const CONFIG_FILE = 'planner.config.json';
 const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
@@ -15,11 +17,22 @@ export function isUsableEndpoint(value) {
     const text = value.trim();
     if (!text)
         return false;
-    if (text.startsWith('/') && !text.startsWith('//'))
-        return true;
     try {
-        const url = new URL(text);
-        return url.protocol === 'http:' || url.protocol === 'https:';
+        const relative = text.startsWith('/') && !text.startsWith('//');
+        const url = new URL(text, relative ? 'https://planner.invalid' : undefined);
+        if (!relative && url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+        if (url.username || url.password)
+            return false;
+        if (url.hash)
+            return false;
+        for (const name of url.searchParams.keys()) {
+            if (/^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name)) {
+                return false;
+            }
+        }
+        return true;
     }
     catch {
         return false;
@@ -48,13 +61,52 @@ function parsePresetDefinition(value) {
     };
 }
 const fallback = (why) => ({
-    config: DEFAULT_INFERENCE,
-    notice: `The assistant settings could not be used (${why}), so it runs in your browser instead.`,
+    config: MANUAL_INFERENCE,
+    notice: `The assistant settings could not be used (${why}), so inference is off. The planner still works manually.`,
 });
+function parseAlternatives(value, initial) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length === 0)
+        return null;
+    const modes = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string' ||
+            !INFERENCE_MODES.includes(entry) ||
+            entry === initial ||
+            modes.includes(entry)) {
+            return null;
+        }
+        modes.push(entry);
+    }
+    return modes;
+}
+function parseByo(value) {
+    if (value === undefined)
+        return {};
+    if (!isObject(value))
+        return null;
+    if (value.presets === undefined)
+        return {};
+    if (!Array.isArray(value.presets) || value.presets.length === 0)
+        return null;
+    const presets = [];
+    for (const entry of value.presets) {
+        if (typeof entry === 'string' && entry.trim()) {
+            presets.push(entry.trim());
+            continue;
+        }
+        const definition = parsePresetDefinition(entry);
+        if (!definition)
+            return null;
+        presets.push(definition);
+    }
+    return { presets };
+}
 /**
- * Validate a parsed config. Anything wrong (unknown mode, `host` without a
- * usable endpoint, a malformed preset list) falls back to `browser` with a
- * notice, never to a half-working mode.
+ * Validate a parsed config. A missing config keeps the standalone browser
+ * default. A present but invalid config fails closed to manual planning with a
+ * visible notice; it never selects a provider or downloads a model.
  */
 export function validateInferenceConfig(value) {
     if (!isObject(value))
@@ -65,43 +117,47 @@ export function validateInferenceConfig(value) {
     if (!isObject(inference))
         return fallback('"inference" is not an object');
     const mode = inference.mode;
-    if (mode === undefined || mode === 'browser') {
+    if (mode === undefined)
         return { config: DEFAULT_INFERENCE };
+    if (!INFERENCE_MODES.includes(mode)) {
+        return fallback(`unknown mode "${String(mode)}"`);
+    }
+    const selected = mode;
+    const alternatives = parseAlternatives(inference.alternatives, selected);
+    if (!alternatives) {
+        return fallback('alternatives must be unique supported modes other than mode');
+    }
+    const credentialPersistence = inference.credentialPersistence;
+    if (credentialPersistence !== undefined &&
+        credentialPersistence !== 'local' &&
+        credentialPersistence !== 'memory') {
+        return fallback('credentialPersistence must be "local" or "memory"');
     }
-    if (mode === 'host') {
-        const host = inference.host;
-        if (!isObject(host) || !isUsableEndpoint(host.endpoint)) {
+    const modes = [selected, ...alternatives];
+    let host;
+    if (modes.includes('host')) {
+        const configuredHost = inference.host;
+        if (!isObject(configuredHost) ||
+            !isUsableEndpoint(configuredHost.endpoint)) {
             return fallback('host mode needs host.endpoint, an http(s) URL or path');
         }
-        return {
-            config: { mode: 'host', host: { endpoint: host.endpoint.trim() } },
-        };
+        host = { endpoint: configuredHost.endpoint.trim() };
     }
-    if (mode === 'byo') {
-        const byo = inference.byo;
-        if (byo === undefined)
-            return { config: { mode: 'byo' } };
-        if (!isObject(byo))
-            return fallback('"byo" is not an object');
-        if (byo.presets === undefined)
-            return { config: { mode: 'byo', byo: {} } };
-        if (!Array.isArray(byo.presets) || byo.presets.length === 0) {
-            return fallback('byo.presets must be a non-empty list');
-        }
-        const presets = [];
-        for (const entry of byo.presets) {
-            if (typeof entry === 'string' && entry.trim()) {
-                presets.push(entry.trim());
-                continue;
-            }
-            const definition = parsePresetDefinition(entry);
-            if (!definition)
-                return fallback('a byo preset is malformed');
-            presets.push(definition);
-        }
-        return { config: { mode: 'byo', byo: { presets } } };
+    let byo;
+    if (modes.includes('byo')) {
+        byo = parseByo(inference.byo) ?? undefined;
+        if (!byo)
+            return fallback('byo.presets must be a non-empty valid list');
     }
-    return fallback(`unknown mode "${String(mode)}"`);
+    return {
+        config: {
+            mode: selected,
+            ...(alternatives.length ? { alternatives } : {}),
+            ...(credentialPersistence ? { credentialPersistence } : {}),
+            ...(host ? { host } : {}),
+            ...(byo ? { byo } : {}),
+        },
+    };
 }
 /** Parse the file's text. */
 export function parseInferenceConfig(text) {

package/dist/inference/openai.js

@@ -9,6 +9,11 @@ export function normalizeBaseUrl(value) {
         // Credentials in a URL would travel in the clear as part of it.
         if (url.username || url.password)
             return null;
+        for (const name of url.searchParams.keys()) {
+            if (/^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name)) {
+                return null;
+            }
+        }
         return `${url.origin}${url.pathname.replace(/\/+$/, '')}`;
     }
     catch {

package/dist/kitchen/LiveKitchenBridge.svelte

@@ -0,0 +1,73 @@
+<script lang="ts">
+import { onMount } from 'svelte';
+import { createHostSession } from '../planner/host/session.svelte.js';
+import { callLiveKitchen, type LiveKitchenBinding } from './live.js';
+
+let {
+  binding,
+  onlock,
+}: { binding: LiveKitchenBinding; onlock?: (locked: boolean) => void } =
+  $props();
+const session = createHostSession((name, args) =>
+  callLiveKitchen(binding, name, args),
+);
+
+$effect(() => {
+  onlock?.(session.locked);
+  return () => onlock?.(false);
+});
+
+onMount(() => {
+  const stop = session.mount();
+  void session.connect(binding.planId);
+  const timer = setInterval(() => {
+    if (
+      !session.busy &&
+      !session.retryable &&
+      document.visibilityState === 'visible'
+    ) {
+      void session.connect(binding.planId);
+    }
+  }, 1500);
+  return () => {
+    clearInterval(timer);
+    stop();
+  };
+});
+</script>
+
+{#if session.error}
+  <p role="alert" class="bridge-error">Kitchen live preview: {session.error}</p>
+{/if}
+{#if session.preservedDraft && !session.retryable}
+  <details class="bridge-preserved">
+    <summary>Preserved edit</summary>
+    <textarea readonly aria-label="Preserved cookbook edit" value={JSON.stringify(session.preservedDraft, null, 2)}></textarea>
+    <button type="button" onclick={() => session.dismissPreservedDraft()}>Dismiss preserved edit</button>
+  </details>
+{/if}
+{#if session.retryable}
+  <div class="bridge-backdrop" aria-hidden="true"></div>
+  <div class="bridge-recovery" role="dialog" aria-modal="true" aria-labelledby="bridge-recovery-title">
+    <h2 id="bridge-recovery-title">Kitchen edit needs attention</h2>
+    <p>The app is paused until this edit is retried. The same command will be sent so Kitchen can safely recognize a previous success.</p>
+    {#if session.draft}
+      <label for="bridge-draft">Preserved cookbook edit</label>
+      <textarea id="bridge-draft" readonly value={JSON.stringify(session.draft, null, 2)}></textarea>
+    {/if}
+    <button type="button" disabled={session.busy} onclick={() => session.retry()}>Retry same edit</button>
+  </div>
+{/if}
+
+<style>
+@layer smrt.reset, smrt.structure, smrt.theme;
+@layer smrt.theme {
+  .bridge-error { margin: 0; padding: var(--smrt-spacing-2, .5rem) var(--smrt-spacing-4, 1rem); color: var(--smrt-color-on-error-container, #b91c1c); background: var(--smrt-color-error-container, #fef2f2); }
+  .bridge-backdrop { position: fixed; inset: 0; z-index: 9998; background: rgb(0 0 0 / .45); }
+  .bridge-recovery { position: fixed; z-index: 9999; inset-inline: max(1rem, calc((100vw - 32rem) / 2)); top: 15vh; display: grid; gap: .75rem; padding: 1.5rem; border-radius: var(--smrt-radius-large, .75rem); background: var(--smrt-surface-raised, white); color: var(--smrt-color-on-surface, black); box-shadow: var(--smrt-elevation-4); }
+  .bridge-recovery h2, .bridge-recovery p { margin: 0; }
+  .bridge-preserved { padding: var(--smrt-spacing-2, .5rem) var(--smrt-spacing-4, 1rem); color: var(--smrt-color-on-error-container, #b91c1c); background: var(--smrt-color-error-container, #fef2f2); }
+  .bridge-preserved textarea { width: 100%; min-height: 8rem; }
+  .bridge-recovery textarea { min-height: 10rem; max-height: 35vh; width: 100%; }
+}
+</style>

package/dist/kitchen/LiveKitchenBridge.svelte.d.ts

@@ -0,0 +1,8 @@
+import { type LiveKitchenBinding } from './live.ts';
+type $$ComponentProps = {
+    binding: LiveKitchenBinding;
+    onlock?: (locked: boolean) => void;
+};
+declare const LiveKitchenBridge: import("svelte").Component<$$ComponentProps, {}, "">;
+type LiveKitchenBridge = ReturnType<typeof LiveKitchenBridge>;
+export default LiveKitchenBridge;

package/dist/kitchen/client.js

@@ -27,11 +27,17 @@ function usableEndpoint(value) {
     if (typeof value !== 'string')
         return false;
     const text = value.trim();
-    if (text.startsWith('/') && !text.startsWith('//'))
-        return true;
     try {
-        const url = new URL(text);
-        return url.protocol === 'http:' || url.protocol === 'https:';
+        const relative = text.startsWith('/') && !text.startsWith('//');
+        const url = new URL(text, relative ? 'https://planner.invalid' : undefined);
+        if (!relative && url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+        if (url.username || url.password)
+            return false;
+        if (url.hash)
+            return false;
+        return ![...url.searchParams.keys()].some((name) => /^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name));
     }
     catch {
         return false;

package/dist/kitchen/live.d.ts

@@ -0,0 +1,7 @@
+/** Development preview binding: a single Kitchen plan and loopback bridge. */
+export interface LiveKitchenBinding {
+    planId: string;
+    port: number;
+}
+export declare function liveKitchenBinding(search: string): LiveKitchenBinding | null;
+export declare function callLiveKitchen(binding: LiveKitchenBinding, name: string, args: Record<string, unknown>): Promise<unknown>;

package/dist/kitchen/live.js

@@ -0,0 +1,51 @@
+const KEY = 'smrt-planner:live-kitchen:v1';
+const PLAN_ID = /^plan-[a-f0-9-]{8,36}$/;
+function valid(value) {
+    const binding = value;
+    return (!!binding &&
+        PLAN_ID.test(binding.planId) &&
+        Number.isInteger(binding.port) &&
+        binding.port > 0 &&
+        binding.port <= 65535);
+}
+export function liveKitchenBinding(search) {
+    const params = new URLSearchParams(search);
+    const planId = params.get('kitchenPlan');
+    const port = Number(params.get('kitchenPort'));
+    const fromUrl = { planId, port };
+    if (valid(fromUrl)) {
+        try {
+            sessionStorage.setItem(KEY, JSON.stringify(fromUrl));
+        }
+        catch {
+            /* URL still binds this tab. */
+        }
+        return fromUrl;
+    }
+    try {
+        const saved = JSON.parse(sessionStorage.getItem(KEY) ?? 'null');
+        return valid(saved) ? saved : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function callLiveKitchen(binding, name, args) {
+    if (args.planId !== binding.planId)
+        throw new Error('Preview plan id changed.');
+    const root = `http://127.0.0.1:${binding.port}/plans/${binding.planId}`;
+    const response = name === 'get_plan'
+        ? await fetch(root, { cache: 'no-store' })
+        : name === 'run_commands'
+            ? await fetch(`${root}/commands`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(args),
+            })
+            : null;
+    if (!response)
+        throw new Error(`Preview tool ${name} is unavailable.`);
+    if (!response.ok)
+        throw new Error(`Kitchen preview answered ${response.status}.`);
+    return response.json();
+}

package/dist/library/icons.js

@@ -23,4 +23,38 @@ export const COOKBOOK_ICONS = {
         'M17 20l-1-5h-5l1-7',
         'M4 10l4-1l4-1l4 1.5l4 1.5',
     ],
+    leaf: [
+        'M5 21c.5-4.5 2.5-8 7-10',
+        'M9 18c6.218 0 10.5-3.288 11-12v-2h-4.014c-9 0-11.986 4-12 9c0 1 0 3 2 5h3z',
+    ],
+    scissors: [
+        'M6 7m-3 0a3 3 0 1 0 6 0a3 3 0 1 0-6 0',
+        'M6 17m-3 0a3 3 0 1 0 6 0a3 3 0 1 0-6 0',
+        'M8.6 8.6l10.4 10.4',
+        'M8.6 15.4l10.4-10.4',
+    ],
+    coffee: [
+        'M3 14c.83.642 2.077 1.017 3.5 1c1.423.017 2.67-.358 3.5-1c.83-.642 2.077-1.017 3.5-1c1.423-.017 2.67.358 3.5 1',
+        'M8 3a2.4 2.4 0 0 0-1 2a2.4 2.4 0 0 0 1 2',
+        'M12 3a2.4 2.4 0 0 0-1 2a2.4 2.4 0 0 0 1 2',
+        'M3 10h14v5a6 6 0 0 1-6 6h-2a6 6 0 0 1-6-6v-5z',
+        'M16.746 16.726a3 3 0 1 0 .252-5.555',
+    ],
+    forklift: [
+        'M5 17m-2 0a2 2 0 1 0 4 0a2 2 0 1 0-4 0',
+        'M13 17m-2 0a2 2 0 1 0 4 0a2 2 0 1 0-4 0',
+        'M7 17h4',
+        'M3 17v-6h13v6',
+        'M5 11v-4h4',
+        'M9 11v-6h4l3 6',
+        'M22 15h-3v-10',
+        'M16 13h3',
+    ],
+    heart: [
+        'M19.5 12.572l-7.5 7.428l-7.5-7.428a5 5 0 1 1 7.5-6.566a5 5 0 1 1 7.5 6.572',
+    ],
+    pencil: [
+        'M4 20h4l10.5-10.5a2.828 2.828 0 1 0-4-4l-10.5 10.5v4',
+        'M13.5 6.5l4 4',
+    ],
 };