@dfosco/storyboard 0.7.1 → 0.9.0

package/src/core/workshop/features/createPrototype/server.js

@@ -21,6 +21,7 @@ import {
   buildTemplateRecipeIndex,
   resolveTemplateRecipeEntry,
 } from '../templateIndex.js'
+import { readWorkshopPartials } from '../partialRender.js'
 
 const FLOW_SKELETON = JSON.stringify({ $global: [] }, null, 2) + '\n'
 
@@ -178,7 +179,10 @@ function generatePrototypeJson({ title, author, description, partialEntry, url }
  */
 export function createPrototypesHandler(ctx) {
   const { root, sendJson, workshopConfig = {} } = ctx
-  const getTemplateRecipes = () => buildTemplateRecipeIndex(root, workshopConfig.partials)
+  const getTemplateRecipes = () => {
+    const partials = readWorkshopPartials(root)
+    return buildTemplateRecipeIndex(root, partials.length ? partials : workshopConfig.partials)
+  }
 
   return async (req, res, { body, path: routePath, method }) => {
     const templateRecipes = getTemplateRecipes()

package/src/core/workshop/features/templateIndex.js

@@ -70,6 +70,26 @@ function makeId(prefix, directory, name, prototype, folder) {
   return `prototype:${folderPart}${prototype}:${directory}/${name}`
 }
 
+/**
+ * Resolve the actual filesystem directory for a global partial. The
+ * config says `directory: "template"` (singular) but the filesystem may
+ * use `templates` (plural). Probe both, return whichever exists. Returns
+ * `null` when neither directory contains the named partial.
+ */
+function resolveGlobalPartialBaseDir(srcRoot, configDirectory, name) {
+  const kind = toPartialKind(configDirectory)
+  if (!kind) return null
+  // Both spellings are accepted in config; the actual on-disk dir may
+  // differ. Try the config spelling first, then the alternative.
+  const alternatives = kind === 'template'
+    ? Array.from(new Set([configDirectory, 'templates', 'template']))
+    : Array.from(new Set([configDirectory, 'recipes', 'recipe']))
+  for (const dir of alternatives) {
+    if (fs.existsSync(path.join(srcRoot, dir, name))) return dir
+  }
+  return null
+}
+
 export function buildTemplateRecipeIndex(root, configPartials = []) {
   const srcRoot = path.join(root, 'src')
   const results = []
@@ -82,13 +102,20 @@ export function buildTemplateRecipeIndex(root, configPartials = []) {
     const id = makeId('global', partial.directory, partial.name)
     if (seenIds.has(id)) continue
     seenIds.add(id)
+    // Resolve baseDir to the directory that actually exists on disk so
+    // downstream code (operations.js createPrototype) reads the right
+    // path. Without this, a config with `directory: "template"` while
+    // the files live in `src/templates/` would silently fail at write
+    // time and leave an orphaned .prototype.json behind.
+    const resolvedBaseDir = resolveGlobalPartialBaseDir(srcRoot, partial.directory, partial.name)
+      || partial.directory
     results.push({
       id,
       name: partial.name,
       directory: partial.directory,
       kind,
       scope: 'global',
-      baseDir: partial.directory,
+      baseDir: resolvedBaseDir,
       globals: Array.isArray(partial.globals) ? partial.globals : undefined,
     })
   }

package/src/core/worktree/port.js

@@ -30,7 +30,22 @@ const BASE_PORT = 1234
  * @returns {string} absolute path to ports.json
  */
 export function portsFilePath(cwd = process.cwd()) {
-  const realCwd = realpathSync(cwd)
+  // Defensive: cwd may have just been deleted out from under us (e.g. a
+  // workleaf merge cleaning up its own directory before releasing the
+  // port). Fall back to the raw path so callers don't ENOENT.
+  let realCwd
+  try {
+    realCwd = realpathSync(cwd)
+  } catch {
+    realCwd = cwd
+  }
+
+  // Check workleaf first — its path is `<root>/workleafs/<parent>/workleaf--<slug>`
+  // so the prefix capture must NOT swallow that segment when we're inside one.
+  const workleafMatch = realCwd.match(/^(.+)[/\\]workleafs[/\\][^/\\]+[/\\]workleaf--[^/\\]+/)
+  if (workleafMatch) {
+    return join(workleafMatch[1], 'worktrees', 'ports.json')
+  }
 
   // Check if we're inside worktrees/<name>/ or .worktrees/<name>/
   const worktreeMatch = realCwd.match(/^(.+)[/\\]\.?worktrees[/\\][^/\\]+/)
@@ -45,20 +60,35 @@ export function portsFilePath(cwd = process.cwd()) {
 /**
  * Detect the worktree name from the current git context.
  *
- * Returns 'main' when not inside a worktrees/<name>/ or
- * .worktrees/<name>/ directory.
+ * Returns:
+ *   - The compound branch name `<parent>--workleaf--<slug>` when cwd
+ *     is inside a `workleafs/<parent>/workleaf--<slug>/` directory.
+ *     This keeps `storyboard dev` (and every consumer that calls
+ *     this helper) working from inside a workleaf with zero changes.
+ *   - The worktree name when cwd is inside `worktrees/<name>/` or
+ *     `.worktrees/<name>/`.
+ *   - The current branch name when on a non-main/master branch.
+ *   - `'main'` otherwise.
  */
 export function detectWorktreeName() {
   try {
     const topLevel = execSync('git rev-parse --show-toplevel', { encoding: 'utf8' }).trim()
     const realTop = realpathSync(topLevel)
 
+    // Check workleaf first — `workleafs/<parent>/workleaf--<slug>` is
+    // the most specific pattern and overlaps with the worktree match
+    // when the parent is itself a worktree.
+    const workleafMatch = realTop.match(/[/\\]workleafs[/\\]([^/\\]+)[/\\]workleaf--([^/\\]+)$/)
+    if (workleafMatch) return `${workleafMatch[1]}--workleaf--${workleafMatch[2]}`
+
     // Check if we're inside a worktrees/<name> or .worktrees/<name> directory
     const wtMatch = realTop.match(/[/\\]\.?worktrees[/\\]([^/\\]+)$/)
     if (wtMatch) return wtMatch[1]
 
-    // Also check the cwd pattern
+    // Also check the cwd pattern (workleaf first, then worktree)
     const realCwd = realpathSync(process.cwd())
+    const cwdWorkleafMatch = realCwd.match(/[/\\]workleafs[/\\]([^/\\]+)[/\\]workleaf--([^/\\]+)/)
+    if (cwdWorkleafMatch) return `${cwdWorkleafMatch[1]}--workleaf--${cwdWorkleafMatch[2]}`
     const worktreeMatch = realCwd.match(/\.?worktrees[/\\]([^/\\]+)/)
     if (worktreeMatch) return worktreeMatch[1]
 
@@ -226,7 +256,20 @@ export function slugify(name) {
  * @returns {string} absolute path to repo root
  */
 export function repoRoot(cwd = process.cwd()) {
-  const realCwd = realpathSync(cwd)
+  // Defensive: cwd may have been deleted (e.g. during workleaf cleanup).
+  // Fall back to raw cwd so the regex matchers still get a useful path.
+  let realCwd
+  try {
+    realCwd = realpathSync(cwd)
+  } catch {
+    realCwd = cwd
+  }
+
+  // Workleaf wins over worktree: `workleafs/<parent>/workleaf--<slug>`
+  // appears below the parent worktree on disk, but the repo root is
+  // always the directory containing the top-level `workleafs/` dir.
+  const workleafMatch = realCwd.match(/^(.+)[/\\]workleafs[/\\][^/\\]+[/\\]workleaf--[^/\\]+/)
+  if (workleafMatch) return workleafMatch[1]
 
   const worktreeMatch = realCwd.match(/^(.+)[/\\]\.?worktrees[/\\][^/\\]+/)
   if (worktreeMatch) return worktreeMatch[1]

package/src/core/worktree/port.test.js

@@ -164,6 +164,48 @@ describe('repoRoot', () => {
     const wt = join(tempRoot, '.worktrees', 'legacy-branch')
     expect(repoRoot(wt)).toBe(tempRoot)
   })
+
+  it('returns parent of workleafs when inside a workleaf (main-parented)', () => {
+    const wl = join(tempRoot, 'workleafs', 'main', 'workleaf--fix')
+    mkdirSync(wl, { recursive: true })
+    expect(repoRoot(wl)).toBe(tempRoot)
+  })
+
+  it('returns parent of workleafs when inside a workleaf (worktree-parented)', () => {
+    const wl = join(tempRoot, 'workleafs', '4.3.0', 'workleaf--bench')
+    mkdirSync(wl, { recursive: true })
+    expect(repoRoot(wl)).toBe(tempRoot)
+  })
+
+  it('returns parent of workleafs even from a nested cwd inside a workleaf', () => {
+    const wl = join(tempRoot, 'workleafs', 'main', 'workleaf--fix', 'src', 'core')
+    mkdirSync(wl, { recursive: true })
+    expect(repoRoot(wl)).toBe(tempRoot)
+  })
+})
+
+describe('portsFilePath (workleaf-aware)', () => {
+  let tempRoot
+
+  beforeEach(() => {
+    tempRoot = realpathSync(mkdtempSync(join(tmpdir(), 'sb-port-wl-')))
+  })
+
+  afterEach(() => {
+    rmSync(tempRoot, { recursive: true, force: true })
+  })
+
+  it('returns root worktrees/ports.json from inside a workleaf', () => {
+    const wl = join(tempRoot, 'workleafs', 'main', 'workleaf--fix')
+    mkdirSync(wl, { recursive: true })
+    expect(portsFilePath(wl)).toBe(join(tempRoot, 'worktrees', 'ports.json'))
+  })
+
+  it('returns root worktrees/ports.json from inside a worktree-parented workleaf', () => {
+    const wl = join(tempRoot, 'workleafs', '4.3.0', 'workleaf--bench')
+    mkdirSync(wl, { recursive: true })
+    expect(portsFilePath(wl)).toBe(join(tempRoot, 'worktrees', 'ports.json'))
+  })
 })
 
 describe('worktreeDir', () => {

package/src/internals/ArtifactForm/ArtifactForm.jsx

@@ -3,6 +3,11 @@
  * submit actions for any artifact type. Surfaces identically across the
  * command palette, canvas add menu, and workspace.
  *
+ * Styling: the form is built on the BaseUiForm primitives (`@base-ui/react`
+ * + workspace-style CSS) — Mona Sans, pill buttons, clean white cards.
+ * This replaced the prior Primer-based implementation so artifact creation
+ * shares the SimpleWorkspace look across every surface.
+ *
  * Modes:
  *   <ArtifactForm type="prototype" onSubmit={fn} />   // single type
  *   <ArtifactForm onSubmit={fn} />                    // type picker
@@ -11,32 +16,64 @@
  *   Schemas may declare `field.dynamic = 'prototypes'`. Pass
  *   `dynamicOptions={{ prototypes: ['my-app', ...] }}` to populate them.
  */
-import { useState, useMemo, useEffect } from 'react'
-import { FormControl, Button, TextInput, Textarea, Flash, Text, ActionMenu, ActionList } from '@primer/react'
-import { ARTIFACT_SCHEMAS, validateArtifact } from './artifactSchemas.js'
+import { useState, useMemo, useEffect, useRef } from 'react'
+import {
+  Form,
+  Field,
+  Label,
+  Description,
+  Validation,
+  TextInput,
+  Textarea,
+  Select,
+  Checkbox,
+  Button,
+  Flash,
+  Menu,
+} from '../BaseUiForm/BaseUiForm.jsx'
+import { ARTIFACT_SCHEMAS, validateArtifact, isFieldVisible } from './artifactSchemas.js'
 import styles from './ArtifactForm.module.css'
 
+/**
+ * Slugify a freeform string into the kebab-case form the `name` field expects.
+ * Mirrors the NAME_PATTERN in artifactSchemas.js — lowercase letters, digits,
+ * and hyphens. Used to auto-derive `name` from `title` while the user types,
+ * until they manually edit `name` themselves.
+ */
+function slugifyName(value) {
+  return String(value || '')
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 64)
+}
+
 function TypeSelector({ selected, onChange }) {
   const types = Object.entries(ARTIFACT_SCHEMAS)
   const current = ARTIFACT_SCHEMAS[selected]
 
   return (
-    <ActionMenu>
-      <ActionMenu.Button className={styles.typeButton}>
-        {current?.icon} {current?.label || 'Select type…'}
-      </ActionMenu.Button>
-      <ActionMenu.Overlay width="medium">
-        <ActionList selectionVariant="single">
-          {types.map(([key, schema]) => (
-            <ActionList.Item key={key} selected={key === selected} onSelect={() => onChange(key)}>
-              <ActionList.LeadingVisual>{schema.icon}</ActionList.LeadingVisual>
-              {schema.label}
-              <ActionList.Description variant="block">{schema.description}</ActionList.Description>
-            </ActionList.Item>
-          ))}
-        </ActionList>
-      </ActionMenu.Overlay>
-    </ActionMenu>
+    <Menu>
+      <Menu.Button>
+        <span>{current?.icon}</span>
+        <span>{current?.label || 'Select type…'}</span>
+      </Menu.Button>
+      <Menu.Items>
+        {types.map(([key, schema]) => (
+          <Menu.Item
+            key={key}
+            selected={key === selected}
+            onSelect={() => onChange(key)}
+            description={schema.description}
+          >
+            <span>{schema.icon}</span>
+            <span>{schema.label}</span>
+          </Menu.Item>
+        ))}
+      </Menu.Items>
+    </Menu>
   )
 }
 
@@ -49,9 +86,8 @@ function FieldRenderer({ field, value, error, onChange, options }) {
           value={value || ''}
           onChange={e => onChange(e.target.value)}
           placeholder={field.placeholder}
-          block
           type={field.type === 'url' ? 'url' : 'text'}
-          validationStatus={error ? 'error' : undefined}
+          invalid={!!error}
         />
       )
     case 'textarea':
@@ -60,8 +96,8 @@ function FieldRenderer({ field, value, error, onChange, options }) {
           value={value || ''}
           onChange={e => onChange(e.target.value)}
           placeholder={field.placeholder}
-          block
           rows={3}
+          invalid={!!error}
         />
       )
     case 'code':
@@ -70,52 +106,26 @@ function FieldRenderer({ field, value, error, onChange, options }) {
           value={value || ''}
           onChange={e => onChange(e.target.value)}
           placeholder={field.placeholder}
-          block
           rows={8}
           className={styles.codeField}
+          invalid={!!error}
         />
       )
     case 'select':
-      // options may be an array of strings or objects { value, label, group }.
-      // When grouped, we render <optgroup>s so templates and recipes appear
-      // under headings (mirrors the workshop form's grouping).
-      {
-        const norm = (options || []).map(o =>
-          typeof o === 'string' ? { value: o, label: o, group: null } : { group: null, ...o }
-        )
-        const grouped = norm.some(o => o.group)
-        return (
-          <select
-            className={styles.select}
-            value={value || ''}
-            onChange={e => onChange(e.target.value)}
-          >
-            <option value="">{field.placeholder || 'Select…'}</option>
-            {grouped
-              ? Object.entries(norm.reduce((acc, opt) => {
-                  const key = opt.group || 'Other'
-                  ;(acc[key] = acc[key] || []).push(opt)
-                  return acc
-                }, {})).map(([group, opts]) => (
-                  <optgroup key={group} label={group}>
-                    {opts.map(opt => <option key={opt.value} value={opt.value}>{opt.label}</option>)}
-                  </optgroup>
-                ))
-              : norm.map(opt => <option key={opt.value} value={opt.value}>{opt.label}</option>)
-            }
-          </select>
-        )
-      }
+      return (
+        <Select
+          value={value || ''}
+          onChange={val => onChange(val)}
+          options={options || []}
+          placeholder={field.placeholder || 'Select…'}
+          invalid={!!error}
+        />
+      )
     case 'checkbox':
       return (
-        <label className={styles.checkboxLabel}>
-          <input
-            type="checkbox"
-            checked={!!value}
-            onChange={e => onChange(e.target.checked)}
-          />
-          <span>{field.checkboxLabel || field.label}</span>
-        </label>
+        <Checkbox checked={!!value} onChange={v => onChange(v)}>
+          {field.checkboxLabel || field.label}
+        </Checkbox>
       )
     default:
       return null
@@ -132,6 +142,38 @@ function initialValues(schema) {
   return initial
 }
 
+/**
+ * Render one Field wrapper for a schema field. Checkbox fields hide the
+ * standalone label because the inline label inside the Checkbox already
+ * names the control — otherwise the label appears twice. Descriptions
+ * render under the input when there's no error (same pattern as
+ * `patternHint`).
+ */
+function renderField(field, { values, errors, dynamicOptions, handleChange }) {
+  const options = field.dynamic ? dynamicOptions[field.dynamic] : field.options
+  const isCheckbox = field.type === 'checkbox'
+  const errorMessage = errors[field.name]
+  return (
+    <Field key={field.name} invalid={!!errorMessage}>
+      {isCheckbox
+        ? <Label visuallyHidden>{field.label}</Label>
+        : <Label required={field.required}>{field.label}</Label>
+      }
+      <FieldRenderer
+        field={field}
+        value={values[field.name]}
+        error={errorMessage}
+        onChange={val => handleChange(field.name, val)}
+        options={options}
+      />
+      {errorMessage && <Validation>{errorMessage}</Validation>}
+      {!errorMessage && (field.caption || field.patternHint) && (
+        <Description>{field.caption || field.patternHint}</Description>
+      )}
+    </Field>
+  )
+}
+
 export default function ArtifactForm({
   type: fixedType,
   onSubmit,
@@ -150,18 +192,66 @@ export default function ArtifactForm({
   const [errors, setErrors] = useState({})
   const [submitting, setSubmitting] = useState(false)
 
+  // Tracks whether the `name` field should keep auto-following `title`.
+  // Flips to false the first time the user edits `name` directly, so we don't
+  // clobber their input. Reset on type change or unmount.
+  const nameAutoFollowRef = useRef(true)
+
   // Reset form when fixed type changes (parent-controlled)
   useEffect(() => {
     if (!fixedType) return
     setValues({ ...initialValues(ARTIFACT_SCHEMAS[fixedType]), ...(initialOverride || {}) })
     setErrors({})
     setSubmitting(false)
+    nameAutoFollowRef.current = true
   }, [fixedType])
 
+  // Merge late-arriving initial overrides (e.g. a gh-login fetch that resolves
+  // after mount) into empty fields. Only fills fields the user hasn't typed
+  // into yet, so we never overwrite their input. Stringify the override so the
+  // dep check fires on content changes rather than parent re-render identity.
+  const overrideKey = useMemo(() => JSON.stringify(initialOverride || {}), [initialOverride])
+  useEffect(() => {
+    if (!initialOverride || !schema) return
+    setValues(prev => {
+      let next = prev
+      for (const [k, v] of Object.entries(initialOverride)) {
+        if (v == null || v === '') continue
+        const fieldExists = schema.fields.some(f => f.name === k)
+        const isEmpty = prev[k] === '' || prev[k] == null
+        if (fieldExists && isEmpty) {
+          if (next === prev) next = { ...prev }
+          next[k] = v
+        }
+      }
+      return next
+    })
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [overrideKey, schema])
+
+  // Derive `name` (kebab-case) from `title` as the user types, until they
+  // manually edit `name`. Only applies to schemas that expose both fields
+  // (prototype, canvas, flow). Component uses PascalCase and has no title,
+  // so it's naturally excluded.
+  useEffect(() => {
+    if (!schema || !nameAutoFollowRef.current) return
+    const hasName = schema.fields.some(f => f.name === 'name' && f.type === 'text')
+    const hasTitle = schema.fields.some(f => f.name === 'title')
+    if (!hasName || !hasTitle) return
+    const derived = slugifyName(values.title)
+    if (derived === (values.name || '')) return
+    setValues(prev => ({ ...prev, name: derived }))
+    if (errors.name) {
+      setErrors(prev => { const next = { ...prev }; delete next.name; return next })
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [values.title, schema])
+
   function handleTypeChange(newType) {
     setSelectedType(newType)
     setValues(initialValues(ARTIFACT_SCHEMAS[newType]))
     setErrors({})
+    nameAutoFollowRef.current = true
   }
 
   const [showAdvanced, setShowAdvanced] = useState(false)
@@ -169,8 +259,11 @@ export default function ArtifactForm({
   const visibleFields = useMemo(() => {
     if (!schema) return []
     if (compact) return schema.fields.filter(f => f.required)
-    // Hide mutually-exclusive partner once one side is set
     let fields = schema.fields
+    // Hide fields whose `showIf` predicate is not satisfied (e.g. external
+    // URL only appears when the "External prototype" checkbox is on).
+    fields = fields.filter(f => isFieldVisible(f, values))
+    // Hide mutually-exclusive partner once one side is set
     if (schema.mutuallyExclusive) {
       fields = fields.filter(f => {
         for (const group of schema.mutuallyExclusive) {
@@ -205,6 +298,9 @@ export default function ArtifactForm({
   }
 
   function handleChange(fieldName, value) {
+    if (fieldName === 'name') {
+      nameAutoFollowRef.current = false
+    }
     setValues(prev => ({ ...prev, [fieldName]: value }))
     if (errors[fieldName]) {
       setErrors(prev => { const next = { ...prev }; delete next[fieldName]; return next })
@@ -229,14 +325,19 @@ export default function ArtifactForm({
   }
 
   return (
-    <form className={styles.form} onSubmit={handleSubmit} data-compact={compact || undefined} data-bare={hideHeader || undefined}>
+    <Form
+      className={styles.formShell}
+      onSubmit={handleSubmit}
+      data-compact={compact || undefined}
+      data-bare={hideHeader || undefined}
+    >
       {!hideHeader && (
         <header className={styles.header}>
           <h3 className={styles.title}>
             {operation === 'create' ? 'New' : 'Edit'} {schema.label}
           </h3>
           {!compact && (
-            <Text as="p" className={styles.description}>{schema.description}</Text>
+            <p className={styles.description}>{schema.description}</p>
           )}
         </header>
       )}
@@ -248,29 +349,9 @@ export default function ArtifactForm({
       )}
 
       <div className={styles.fields}>
-        {basicFields.map(field => {
-          const options = field.dynamic ? dynamicOptions[field.dynamic] : field.options
-          return (
-            <FormControl key={field.name} required={field.required}>
-              <FormControl.Label>{field.label}</FormControl.Label>
-              <FieldRenderer
-                field={field}
-                value={values[field.name]}
-                error={errors[field.name]}
-                onChange={val => handleChange(field.name, val)}
-                options={options}
-              />
-              {errors[field.name] && (
-                <FormControl.Validation variant="error">
-                  {errors[field.name]}
-                </FormControl.Validation>
-              )}
-              {field.patternHint && !errors[field.name] && (
-                <FormControl.Caption>{field.patternHint}</FormControl.Caption>
-              )}
-            </FormControl>
-          )
-        })}
+        {basicFields.map(field => renderField(field, {
+          values, errors, dynamicOptions, handleChange,
+        }))}
 
         {advancedFields.length > 0 && (
           <>
@@ -283,29 +364,9 @@ export default function ArtifactForm({
             >
               {showAdvanced ? '− Hide advanced fields' : '+ Advanced fields'}
             </Button>
-            {showAdvanced && advancedFields.map(field => {
-              const options = field.dynamic ? dynamicOptions[field.dynamic] : field.options
-              return (
-                <FormControl key={field.name} required={field.required}>
-                  <FormControl.Label>{field.label}</FormControl.Label>
-                  <FieldRenderer
-                    field={field}
-                    value={values[field.name]}
-                    error={errors[field.name]}
-                    onChange={val => handleChange(field.name, val)}
-                    options={options}
-                  />
-                  {errors[field.name] && (
-                    <FormControl.Validation variant="error">
-                      {errors[field.name]}
-                    </FormControl.Validation>
-                  )}
-                  {field.patternHint && !errors[field.name] && (
-                    <FormControl.Caption>{field.patternHint}</FormControl.Caption>
-                  )}
-                </FormControl>
-              )
-            })}
+            {showAdvanced && advancedFields.map(field => renderField(field, {
+              values, errors, dynamicOptions, handleChange,
+            }))}
           </>
         )}
       </div>
@@ -324,8 +385,8 @@ export default function ArtifactForm({
           {submitting ? 'Creating…' : `${operation === 'create' ? 'Create' : 'Save'} ${schema.label}`}
         </Button>
       </footer>
-    </form>
+    </Form>
   )
 }
 
-export { TypeSelector, ARTIFACT_SCHEMAS, validateArtifact }
+export { TypeSelector, ARTIFACT_SCHEMAS, validateArtifact, isFieldVisible }