domain-driver 0.1.0 → 0.2.0

package/dist/init/init.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+const path = __importStar(require("path"));
+const fs_1 = require("../utils/fs");
+const content_1 = require("./content");
+const markers_1 = require("./markers");
+const SKILL_FILE = '.claude/skills/domain-driver/SKILL.md';
+function runInit(root) {
+    return [writeSection(root, 'AGENTS.md'), writeSection(root, 'CLAUDE.md'), writeSkill(root)];
+}
+function writeSection(root, file) {
+    const filePath = path.join(root, file);
+    const result = (0, markers_1.applySection)((0, fs_1.readTextFile)(filePath), content_1.AGENTS_SECTION);
+    if (result.status !== 'unchanged')
+        (0, fs_1.writeFileSafe)(filePath, result.content);
+    return Object.freeze({ file, status: result.status });
+}
+function writeSkill(root) {
+    const filePath = path.join(root, SKILL_FILE);
+    const existing = (0, fs_1.readTextFile)(filePath);
+    if (existing === content_1.SKILL_CONTENT)
+        return Object.freeze({ file: SKILL_FILE, status: 'unchanged' });
+    (0, fs_1.mkdirSafe)(path.dirname(filePath));
+    (0, fs_1.writeFileSafe)(filePath, content_1.SKILL_CONTENT);
+    return Object.freeze({ file: SKILL_FILE, status: existing === null ? 'created' : 'updated' });
+}

package/dist/init/markers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.END = exports.START = void 0;
+exports.applySection = applySection;
+exports.START = '<!-- domain-driver:start -->';
+exports.END = '<!-- domain-driver:end -->';
+function applySection(existing, section) {
+    if (existing === null) {
+        return { content: `${section}\n`, status: 'created' };
+    }
+    const start = existing.indexOf(exports.START);
+    const end = existing.indexOf(exports.END);
+    if (start !== -1 && end !== -1 && end > start) {
+        const before = existing.slice(0, start);
+        const after = existing.slice(end + exports.END.length);
+        const content = `${before}${section}${after}`;
+        return { content, status: content === existing ? 'unchanged' : 'updated' };
+    }
+    const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+    return { content: `${existing}${separator}${section}\n`, status: 'updated' };
+}

package/dist/postinstall.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldRunPostinstall = shouldRunPostinstall;
+exports.readPackageName = readPackageName;
+exports.run = run;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const init_1 = require("./init/init");
+const NOT_CI = new Set(['', '0', 'false']);
+function shouldRunPostinstall(env, readName) {
+    if (env.CI !== undefined && !NOT_CI.has(env.CI))
+        return { run: false, reason: 'ci' };
+    if (env.npm_config_global === 'true')
+        return { run: false, reason: 'global' };
+    const root = env.INIT_CWD;
+    if (!root)
+        return { run: false, reason: 'no-init-cwd' };
+    const name = readName(root);
+    if (name === null)
+        return { run: false, reason: 'no-consumer-package' };
+    if (name === 'domain-driver')
+        return { run: false, reason: 'self-install' };
+    return { run: true, root };
+}
+function readPackageName(root) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+        const name = parsed.name;
+        return typeof name === 'string' ? name : '';
+    }
+    catch {
+        return null;
+    }
+}
+function run(init = init_1.runInit, env = process.env, readName = readPackageName) {
+    try {
+        const decision = shouldRunPostinstall(env, readName);
+        if (!decision.run)
+            return;
+        for (const result of init(decision.root)) {
+            console.log(`domain-driver: ${result.file} ${result.status}`);
+        }
+    }
+    catch {
+        // A postinstall must never fail an install.
+    }
+}

package/dist/stack/detect.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetStackCache = resetStackCache;
+exports.detectStack = detectStack;
+exports.describeStack = describeStack;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fs_1 = require("../utils/fs");
+const types_1 = require("./types");
+const API_DIRS = ['app/api', 'src/app/api', 'pages/api', 'src/pages/api'];
+let cached;
+function resetStackCache() {
+    cached = undefined;
+}
+function detectStack(override) {
+    if (cached)
+        return cached;
+    const cwd = process.cwd();
+    const overridden = override !== undefined;
+    const deps = readDependencies(cwd, overridden);
+    const stack = overridden ? parseOverride(override) : inferStack(cwd, deps);
+    const result = Object.freeze({
+        stack,
+        source: overridden ? 'override' : 'detected',
+        httpFramework: stack === 'node' ? detectHttpFramework(deps) : null,
+        featureRoot: resolveFeatureRoot(cwd, stack),
+        hasNestjsZod: deps.has('nestjs-zod'),
+    });
+    cached = result;
+    return result;
+}
+function describeStack(stack) {
+    const base = `Stack: ${stack.stack} (${stack.source})`;
+    if (stack.stack !== 'node')
+        return base;
+    return `${base}, http: ${stack.httpFramework ?? 'none'}`;
+}
+function readDependencies(cwd, optional) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        if (optional)
+            return new Set();
+        throw new Error(`No package.json found in ${cwd}. Run domain-driver from your project root, or pass --stack <name>.`);
+    }
+    const pkg = parsePackageJson(pkgPath);
+    return new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+    ]);
+}
+function parsePackageJson(pkgPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return (parsed ?? {});
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Could not parse package.json: ${message}`);
+    }
+}
+function parseOverride(value) {
+    if ((0, types_1.isStackName)(value))
+        return value;
+    throw new Error(`Unknown stack "${value}". Valid stacks: ${types_1.STACK_NAMES.join(', ')}.`);
+}
+function inferStack(cwd, deps) {
+    if (deps.has('@nestjs/core'))
+        return 'nest';
+    if (deps.has('next'))
+        return hasApiDir(cwd) ? 'next-fullstack' : 'next-frontend';
+    if (deps.has('react'))
+        return 'react';
+    return 'node';
+}
+function hasApiDir(cwd) {
+    return API_DIRS.some((dir) => (0, fs_1.isDirectory)(path.join(cwd, dir)));
+}
+function detectHttpFramework(deps) {
+    return types_1.HTTP_FRAMEWORKS.find((name) => deps.has(name)) ?? null;
+}
+function resolveFeatureRoot(cwd, stack) {
+    switch (stack) {
+        case 'next-fullstack':
+        case 'next-frontend':
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src', 'app')) ? 'src/app' : 'app';
+        case 'react':
+        case 'node':
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src')) ? 'src/features' : 'features';
+        case 'nest':
+            return 'src';
+    }
+}

package/dist/stack/profiles/nest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nest = void 0;
+exports.nest = Object.freeze({
+    name: 'nest',
+    folders: ['controllers', 'services', 'repositories', 'schemas', 'dto', 'types'],
+    layers: ['serverService', 'serverRepository', 'controller', 'module', 'dto', 'schema', 'types'],
+    layerDirs: {
+        serverService: 'services',
+        serverRepository: 'repositories',
+        controller: 'controllers',
+        dto: 'dto',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

package/dist/stack/profiles/next-frontend.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFrontend = void 0;
+exports.nextFrontend = Object.freeze({
+    name: 'next-frontend',
+    folders: [
+        'components/client',
+        'components/server',
+        'containers',
+        'hooks',
+        'services',
+        'repositories',
+        'schemas',
+        'types',
+    ],
+    layers: ['page', 'component', 'container', 'hook', 'clientService', 'clientRepository', 'schema', 'types'],
+    layerDirs: {
+        component: 'components',
+        container: 'containers',
+        hook: 'hooks',
+        clientService: 'services',
+        clientRepository: 'repositories',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: true,
+    serverComponents: true,
+});

package/dist/stack/profiles/next-fullstack.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFullstack = void 0;
+exports.nextFullstack = Object.freeze({
+    name: 'next-fullstack',
+    folders: [
+        'components/client',
+        'components/server',
+        'containers',
+        'hooks',
+        'client/services',
+        'client/repositories',
+        'server/services',
+        'server/repositories',
+        'schemas',
+        'types',
+    ],
+    layers: [
+        'page',
+        'component',
+        'container',
+        'hook',
+        'clientService',
+        'clientRepository',
+        'serverService',
+        'serverRepository',
+        'controller',
+        'schema',
+        'types',
+    ],
+    layerDirs: {
+        component: 'components',
+        container: 'containers',
+        hook: 'hooks',
+        clientService: 'client/services',
+        clientRepository: 'client/repositories',
+        serverService: 'server/services',
+        serverRepository: 'server/repositories',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: true,
+    serverComponents: true,
+});

package/dist/stack/profiles/node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.node = void 0;
+exports.node = Object.freeze({
+    name: 'node',
+    folders: ['controllers', 'services', 'repositories', 'schemas', 'types'],
+    layers: ['serverService', 'serverRepository', 'controller', 'schema', 'types'],
+    layerDirs: {
+        serverService: 'services',
+        serverRepository: 'repositories',
+        controller: 'controllers',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

package/dist/stack/profiles/react.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.react = void 0;
+exports.react = Object.freeze({
+    name: 'react',
+    folders: ['components', 'containers', 'hooks', 'services', 'repositories', 'schemas', 'types'],
+    layers: ['component', 'container', 'hook', 'clientService', 'clientRepository', 'schema', 'types'],
+    layerDirs: {
+        component: 'components',
+        container: 'containers',
+        hook: 'hooks',
+        clientService: 'services',
+        clientRepository: 'repositories',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

package/dist/stack/registry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfile = getProfile;
+exports.hasLayer = hasLayer;
+exports.layerDir = layerDir;
+exports.componentDir = componentDir;
+exports.availableCommands = availableCommands;
+exports.assertLayer = assertLayer;
+const next_fullstack_1 = require("./profiles/next-fullstack");
+const next_frontend_1 = require("./profiles/next-frontend");
+const react_1 = require("./profiles/react");
+const node_1 = require("./profiles/node");
+const nest_1 = require("./profiles/nest");
+const PROFILES = Object.freeze({
+    'next-fullstack': next_fullstack_1.nextFullstack,
+    'next-frontend': next_frontend_1.nextFrontend,
+    react: react_1.react,
+    node: node_1.node,
+    nest: nest_1.nest,
+});
+const LAYER_COMMANDS = Object.freeze({
+    component: 'make:component',
+    container: 'make:container',
+    hook: 'make:hook',
+    clientService: 'make:service',
+    serverService: 'make:service',
+    clientRepository: 'make:repository',
+    serverRepository: 'make:repository',
+    controller: 'make:controller',
+    schema: 'make:schema',
+    dto: 'make:schema',
+    types: 'make:types',
+});
+function getProfile(stack) {
+    return PROFILES[stack];
+}
+function hasLayer(profile, layer) {
+    return profile.layers.includes(layer);
+}
+function layerDir(profile, layer) {
+    const dir = profile.layerDirs[layer];
+    if (dir === undefined) {
+        throw new Error(`Layer "${layer}" has no directory in the ${profile.name} profile.`);
+    }
+    return dir;
+}
+function componentDir(profile, type) {
+    return profile.serverComponents ? `components/${type}` : 'components';
+}
+function availableCommands(profile) {
+    const commands = profile.layers
+        .map((layer) => LAYER_COMMANDS[layer])
+        .filter((command) => command !== undefined);
+    return [...new Set(commands)];
+}
+function assertLayer(profile, layer, command) {
+    if (hasLayer(profile, layer))
+        return;
+    const escapeHatch = profile.name === 'next-frontend' && layer === 'controller'
+        ? ' Create an app/api directory or pass --stack next-fullstack to enable route handlers.'
+        : '';
+    throw new Error(`${command} is not available for the ${profile.name} stack. Available: ${availableCommands(profile).join(', ')}.${escapeHatch}`);
+}

package/dist/stack/types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYERS = exports.HTTP_FRAMEWORKS = exports.STACK_NAMES = void 0;
+exports.isStackName = isStackName;
+exports.STACK_NAMES = ['next-fullstack', 'next-frontend', 'react', 'node', 'nest'];
+exports.HTTP_FRAMEWORKS = ['express', 'fastify', 'hono'];
+exports.LAYERS = [
+    'page',
+    'component',
+    'container',
+    'hook',
+    'clientService',
+    'clientRepository',
+    'serverService',
+    'serverRepository',
+    'controller',
+    'module',
+    'dto',
+    'schema',
+    'types',
+];
+function isStackName(value) {
+    return exports.STACK_NAMES.includes(value);
+}

package/dist/templates/actions.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURN_KINDS = exports.WRITE_ACTIONS = exports.ACTIONS = void 0;
+exports.actionCase = actionCase;
+exports.standardAction = standardAction;
+exports.standardActions = standardActions;
+exports.customAction = customAction;
+const naming_1 = require("../utils/naming");
+exports.ACTIONS = ['List', 'Show', 'Create', 'Update', 'Delete'];
+exports.WRITE_ACTIONS = ['Create', 'Update'];
+exports.RETURN_KINDS = ['list', 'one', 'void'];
+const ACTION_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+function actionCase(name) {
+    if (!ACTION_NAME_PATTERN.test(name)) {
+        throw new Error(`Action name "${name}" must be camelCase or PascalCase, for example findActiveUsers.`);
+    }
+    const pascal = (0, naming_1.upperFirst)(name);
+    return Object.freeze({ pascal, camel: (0, naming_1.lowerFirst)(pascal), slug: (0, naming_1.toKebabCase)(pascal) });
+}
+function freeze(spec) {
+    return Object.freeze(spec);
+}
+function returnType(kind, entity) {
+    switch (kind) {
+        case 'list':
+            return `Promise<${entity}[]>`;
+        case 'one':
+            return `Promise<${entity}>`;
+        case 'void':
+            return 'Promise<void>';
+    }
+}
+function standardAction(action, entity) {
+    const name = `${action}${entity}`;
+    const handler = `${(0, naming_1.lowerFirst)(action)}${entity}Controller`;
+    switch (action) {
+        case 'List':
+            return freeze({ name, handler, params: '', args: '', returns: `Promise<${entity}[]>`, usesEntityType: true, schema: null, usesId: false, status: 200, method: 'get', path: '/', failure: `Failed to fetch ${entity} list` });
+        case 'Show':
+            return freeze({ name, handler, params: 'id: string', args: 'id', returns: `Promise<${entity}>`, usesEntityType: true, schema: null, usesId: true, status: 200, method: 'get', path: '/:id', failure: `Failed to fetch ${entity}` });
+        case 'Create':
+            return freeze({ name, handler, params: `data: ${name}`, args: 'data', returns: `Promise<${entity}>`, usesEntityType: true, schema: name, usesId: false, status: 201, method: 'post', path: '/', failure: `Failed to create ${entity}` });
+        case 'Update':
+            return freeze({ name, handler, params: `id: string, data: ${name}`, args: 'id, data', returns: `Promise<${entity}>`, usesEntityType: true, schema: name, usesId: true, status: 200, method: 'put', path: '/:id', failure: `Failed to update ${entity}` });
+        case 'Delete':
+            return freeze({ name, handler, params: 'id: string', args: 'id', returns: 'Promise<void>', usesEntityType: false, schema: null, usesId: true, status: 204, method: 'delete', path: '/:id', failure: `Failed to delete ${entity}` });
+    }
+}
+function standardActions(entity) {
+    return exports.ACTIONS.map((action) => standardAction(action, entity));
+}
+function customAction(entity, actionName, options) {
+    const { pascal, camel, slug } = actionCase(actionName);
+    return freeze({
+        name: pascal,
+        handler: `${camel}Controller`,
+        params: options.withInput ? `data: ${pascal}` : '',
+        args: options.withInput ? 'data' : '',
+        returns: returnType(options.returns, entity),
+        usesEntityType: options.returns !== 'void',
+        schema: options.withInput ? pascal : null,
+        usesId: false,
+        status: options.returns === 'void' ? 204 : 200,
+        method: options.withInput ? 'post' : 'get',
+        path: `/${slug}`,
+        failure: `Failed to ${camel} ${entity}`,
+    });
+}

package/dist/templates/backend/server-repository.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderServerRepository = renderServerRepository;
+const injectable_1 = require("../nest/injectable");
+const signatures_1 = require("../signatures");
+function renderServerRepository(ctx, spec, entity, fromFile) {
+    const cls = `${spec.name}Repository`;
+    const injectable = ctx.profile.name === 'nest';
+    const imports = [
+        ...(injectable ? [injectable_1.INJECTABLE_IMPORT] : []),
+        ...(0, signatures_1.domainImports)(ctx, fromFile, spec, entity),
+    ].join('\n');
+    const header = imports ? `${imports}\n\n` : '';
+    const decorator = injectable ? '@Injectable()\n' : '';
+    return `${header}${decorator}export class ${cls} {
+  async handle(${spec.params}): ${spec.returns} {
+    // TODO: implement with your ORM (Prisma, Drizzle, TypeORM, ...)
+    throw new Error('${cls}.handle is not implemented');
+  }
+}
+`;
+}

package/dist/templates/context.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const path = __importStar(require("path"));
+const registry_1 = require("../stack/registry");
+const imports_1 = require("../utils/imports");
+const paths_1 = require("../utils/paths");
+function createContext(feature, stack, profile) {
+    const dir = (0, paths_1.featureDir)(stack, feature);
+    const importFrom = (fromFile, relative) => (0, imports_1.resolveImport)(fromFile, path.join(dir, relative));
+    return Object.freeze({
+        feature,
+        stack,
+        profile,
+        featureDir: dir,
+        importFrom,
+        importLayer: (fromFile, layer, fileName) => importFrom(fromFile, `${(0, registry_1.layerDir)(profile, layer)}/${fileName}`),
+    });
+}